Actually move the kde files that were renamed in the last commit

1 files changed, 407 insertions, 0 deletions

diff --git a/libtdegames/kgame/kgamepropertyhandler.cpp b/libtdegames/kgame/kgamepropertyhandler.cpp
new file mode 100644
index 00000000..405d433e
--- /dev/null
+++ b/libtdegames/kgame/kgamepropertyhandler.cpp
@@ -0,0 +1,407 @@
+/*
+    This file is part of the KDE games library
+    Copyright (C) 2001 Andreas Beckermann (b_mann@gmx.de)
+    Copyright (C) 2001 Martin Heni (martin@heni-online.de)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License version 2 as published by the Free Software Foundation.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public License
+    along with this library; see the file COPYING.LIB.  If not, write to
+    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+    Boston, MA 02110-1301, USA.
+*/
+/*
+    $Id$
+*/
+
+#include "kgamepropertyhandler.h"
+#include "kgameproperty.h"
+#include "kgamemessage.h"
+
+#include <tqmap.h>
+#include <tqptrqueue.h>
+
+#include <klocale.h>
+#include <typeinfo>
+
+#define KPLAYERHANDLER_LOAD_COOKIE 6239
+
+//---------------------- KGamePropertyHandler -----------------------------------
+class KGamePropertyHandlerPrivate
+{
+public:
+	KGamePropertyHandlerPrivate()
+	{
+	}
+
+	TQMap<int, TQString> mNameMap;
+	TQIntDict<KGamePropertyBase> mIdDict;
+	int mUniqueId;
+	int mId;
+	KGamePropertyBase::PropertyPolicy mDefaultPolicy;
+	bool mDefaultUserspace;
+  int mIndirectEmit;
+  TQPtrQueue<KGamePropertyBase> mSignalQueue;
+};
+
+KGamePropertyHandler::KGamePropertyHandler(int id, const TQObject* receiver, const char * sendf, const char *emitf, TQObject* parent) : TQObject(parent)
+{
+ init();
+ registerHandler(id,receiver,sendf,emitf);
+}
+
+KGamePropertyHandler::KGamePropertyHandler(TQObject* parent) : TQObject(parent)
+{
+ init();
+}
+
+KGamePropertyHandler::~KGamePropertyHandler()
+{
+ clear();
+ delete d;
+}
+
+void KGamePropertyHandler::init()
+{
+ kdDebug(11001) << k_funcinfo << ": this=" << this << endl;
+ d = new KGamePropertyHandlerPrivate; // for future use - is BC important to us?
+ d->mId = 0;
+ d->mUniqueId=KGamePropertyBase::IdAutomatic;
+ d->mDefaultPolicy=KGamePropertyBase::PolicyLocal;
+ d->mDefaultUserspace=true;
+ d->mIndirectEmit=0;
+}
+
+
+int KGamePropertyHandler::id() const
+{
+ return d->mId;
+}
+
+void KGamePropertyHandler::setId(int id)
+{
+ d->mId = id;
+}
+
+void KGamePropertyHandler::registerHandler(int id,const TQObject * receiver, const char * sendf, const char *emitf)
+{
+ setId(id); 
+ if (receiver && sendf) {
+	kdDebug(11001) << "Connecting TQT_SLOT " << sendf << endl;
+	connect(this, TQT_SIGNAL(signalSendMessage(int, TQDataStream &, bool*)), receiver, sendf);
+ }
+ if (receiver && emitf) {
+	kdDebug(11001) << "Connecting TQT_SLOT " << emitf << endl;
+	connect(this, TQT_SIGNAL(signalPropertyChanged(KGamePropertyBase *)), receiver, emitf);
+ }
+}
+
+bool KGamePropertyHandler::processMessage(TQDataStream &stream, int id, bool isSender)
+{
+// kdDebug(11001) << k_funcinfo << ": id=" << id << " mId=" << d->mId << endl;
+ if (id != d->mId) {
+ 	return false; // Is the message meant for us?
+ }
+ KGamePropertyBase* p;
+ int propertyId;
+ KGameMessage::extractPropertyHeader(stream, propertyId);
+// kdDebug(11001) << k_funcinfo << ": Got property " << propertyId << endl;
+ if (propertyId==KGamePropertyBase::IdCommand) {
+	int cmd;
+	KGameMessage::extractPropertyCommand(stream, propertyId, cmd);
+//kdDebug(11001) << k_funcinfo << ": Got COMMAND for id= "<<propertyId <<endl;
+	p = d->mIdDict.find(propertyId);
+	if (p) {
+		if (!isSender || p->policy()==KGamePropertyBase::PolicyClean) {
+			p->command(stream, cmd, isSender);
+		}
+	} else {
+		kdError(11001) << k_funcinfo << ": (cmd): property " << propertyId << " not found" << endl;
+	}
+	return true;
+ }
+ p = d->mIdDict.find(propertyId);
+ if (p) {
+	//kdDebug(11001) << k_funcinfo << ": Loading " << propertyId << endl;
+	if (!isSender || p->policy()==KGamePropertyBase::PolicyClean) {
+		p->load(stream);
+	}
+ } else {
+	kdError(11001) << k_funcinfo << ": property " << propertyId << " not found" << endl;
+ }
+ return true;
+}
+
+bool KGamePropertyHandler::removeProperty(KGamePropertyBase* data)
+{
+ if (!data) {
+	return false;
+ }
+ d->mNameMap.erase(data->id());
+ return d->mIdDict.remove(data->id());
+}
+
+bool KGamePropertyHandler::addProperty(KGamePropertyBase* data, TQString name)
+{
+ //kdDebug(11001) << k_funcinfo << ": " << data->id() << endl;
+ if (d->mIdDict.find(data->id())) {
+	// this id already exists
+	kdError(11001) << "  -> cannot add property " << data->id() << endl;
+	return false;
+ } else {
+	d->mIdDict.insert(data->id(), data);
+  // if here is a check for "is_debug" or so we can add the strings only in debug mode
+  // and save memory!!
+	if (!name.isNull()) {
+		d->mNameMap[data->id()] = name;
+		//kdDebug(11001) << k_funcinfo << ": nid="<< (data->id()) << " inserted in Map name=" << d->mNameMap[data->id()] <<endl;
+		//kdDebug(11001) << "Typeid=" << typeid(data).name() << endl;
+  	//kdDebug(11001) << "Typeid call=" << data->typeinfo()->name() << endl;
+	}
+ }
+ return true;
+}
+
+TQString KGamePropertyHandler::propertyName(int id) const
+{
+ TQString s;
+ if (d->mIdDict.find(id)) {
+	if (d->mNameMap.contains(id)) {
+		s = i18n("%1 (%2)").tqarg(d->mNameMap[id]).tqarg(id);
+	} else {
+		s = i18n("Unnamed - ID: %1").tqarg(id);
+	}
+ } else {
+	// Should _never_ happen
+	s = i18n("%1 unregistered").tqarg(id);
+ }
+ return s;
+}
+
+bool KGamePropertyHandler::load(TQDataStream &stream)
+{
+ // Prevent direct emmiting until all is loaded
+ lockDirectEmit();
+ uint count,i;
+ stream >> count;
+ kdDebug(11001) << k_funcinfo << ": " << count << " KGameProperty objects " << endl;
+ for (i = 0; i < count; i++) {
+	processMessage(stream, id(),false);
+ }
+ TQ_INT16 cookie;
+ stream >> cookie;
+ if (cookie == KPLAYERHANDLER_LOAD_COOKIE) {
+	kdDebug(11001) << "   KGamePropertyHandler loaded propertly"<<endl;
+ } else {
+	kdError(11001) << "KGamePropertyHandler loading error. probably format error"<<endl;
+ }
+ // Allow direct emmiting (if no other lock still holds)
+ unlockDirectEmit();
+ return true;
+}
+
+bool KGamePropertyHandler::save(TQDataStream &stream)
+{
+ kdDebug(11001) << k_funcinfo << ": " << d->mIdDict.count() << " KGameProperty objects " << endl;
+ stream << (uint)d->mIdDict.count();
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.current()) {
+	KGamePropertyBase *base=it.current();
+	if (base) {
+		KGameMessage::createPropertyHeader(stream, base->id());
+		base->save(stream);
+	}
+	++it;
+ }
+ stream << (TQ_INT16)KPLAYERHANDLER_LOAD_COOKIE;
+ return true;
+}
+
+KGamePropertyBase::PropertyPolicy KGamePropertyHandler::policy()
+{
+// kdDebug(11001) << k_funcinfo << ": " << d->mDefaultPolicy << endl;
+ return d->mDefaultPolicy;
+}
+void KGamePropertyHandler::setPolicy(KGamePropertyBase::PropertyPolicy p,bool userspace)
+{
+ // kdDebug(11001) << k_funcinfo << ": " << p << endl;
+ d->mDefaultPolicy=p;
+ d->mDefaultUserspace=userspace;
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.current()) {
+	if (!userspace || it.current()->id()>=KGamePropertyBase::IdUser) {
+		it.current()->setPolicy((KGamePropertyBase::PropertyPolicy)p);
+	}
+	++it;
+ }
+}
+
+void KGamePropertyHandler::unlockProperties()
+{
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.current()) {
+	it.current()->unlock();
+	++it;
+ }
+}
+
+void KGamePropertyHandler::lockProperties()
+{
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.current()) {
+	it.current()->lock();
+	++it;
+ }
+}
+
+int KGamePropertyHandler::uniquePropertyId()
+{
+ return d->mUniqueId++;
+}
+
+void KGamePropertyHandler::flush()
+{
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.current()) {
+	if (it.current()->isDirty()) {
+		it.current()->sendProperty();
+	}
+	++it;
+ }
+}
+
+/* Fire all property signal changed which are collected in
+ * the queque
+ **/
+void KGamePropertyHandler::lockDirectEmit()
+{
+  d->mIndirectEmit++;
+}
+
+void KGamePropertyHandler::unlockDirectEmit()
+{
+  // If the flag is <=0 we emit the queued signals
+  d->mIndirectEmit--;
+  if (d->mIndirectEmit<=0)
+  {
+    KGamePropertyBase *prop;
+    while((prop=d->mSignalQueue.dequeue()) != 0)
+    {
+      // kdDebug(11001) << "emmiting signal for " << prop->id() << endl;
+      emit signalPropertyChanged(prop);
+    }
+  }
+}
+
+void KGamePropertyHandler::emitSignal(KGamePropertyBase *prop)
+{
+ // If the indirect flag is set (load and network transmit)
+ // we cannot emit the signals directly as it can happend that
+ // a sigal causes an access to a property which is e.g. not
+ // yet loaded or received
+
+ if (d->mIndirectEmit>0)
+ {
+  // Queque the signal
+  d->mSignalQueue.enqueue(prop);
+ }
+ else
+ {
+  // directly emit
+  emit signalPropertyChanged(prop);
+ }
+}
+
+bool KGamePropertyHandler::sendProperty(TQDataStream &s)
+{
+ bool sent = false;
+ emit signalSendMessage(id(), s, &sent);
+ return sent;
+}
+
+KGamePropertyBase *KGamePropertyHandler::find(int id)
+{
+ return d->mIdDict.find(id);
+}
+
+void KGamePropertyHandler::clear()
+{
+ kdDebug(11001) << k_funcinfo << id() << endl;
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.toFirst()) {
+	KGamePropertyBase* p = it.toFirst();
+	p->unregisterData();
+	if (d->mIdDict.find(p->id())) {
+		// shouldn't happen - but if mOwner in KGamePropertyBase is NULL
+		// this might be possible
+		removeProperty(p); 
+	}
+ }
+}
+
+TQIntDict<KGamePropertyBase>& KGamePropertyHandler::dict() const
+{ 
+ return d->mIdDict; 
+}
+
+TQString KGamePropertyHandler::propertyValue(KGamePropertyBase* prop)
+{
+ if (!prop) {
+         return i18n("NULL pointer");
+ }
+	   
+ int id = prop->id();
+ TQString name = propertyName(id);
+ TQString value;
+
+ const type_info* t = prop->typeinfo();
+ if (*t == typeid(int)) {
+	value = TQString::number(((KGamePropertyInt*)prop)->value());
+ } else if (*t == typeid(unsigned int)) {
+	value = TQString::number(((KGamePropertyUInt *)prop)->value());
+ } else if (*t == typeid(long int)) {
+	value = TQString::number(((KGameProperty<long int> *)prop)->value()); 
+ } else if (*t == typeid(unsigned long int)) {
+	value = TQString::number(((KGameProperty<unsigned long int> *)prop)->value());
+ } else if (*t == typeid(TQString)) { 
+	value = ((KGamePropertyTQString*)prop)->value();
+ } else if (*t == typeid(TQ_INT8)) { 
+	value = ((KGamePropertyBool*)prop)->value() ?  i18n("True") : i18n("False");
+ } else {
+	emit signalRequestValue(prop, value);
+ }
+		   
+ if (value.isNull()) {
+	value = i18n("Unknown");
+ }
+ return value;
+}
+
+void KGamePropertyHandler::Debug()
+{
+ kdDebug(11001) << "-----------------------------------------------------------" << endl;
+ kdDebug(11001) << "KGamePropertyHandler:: Debug this=" << this << endl;
+
+ kdDebug(11001) << "  Registered properties: (Policy,Lock,Emit,Optimized, Dirty)" << endl;
+ TQIntDictIterator<KGamePropertyBase> it(d->mIdDict);
+ while (it.current()) {
+	KGamePropertyBase *p=it.current();
+	kdDebug(11001) << "  "<< p->id() << ": p=" << p->policy() 
+			<< " l="<<p->isLocked()
+			<< " e="<<p->isEmittingSignal() 
+			<< " o=" << p->isOptimized() 
+			<< " d="<<p->isDirty() 
+			<< endl;
+	++it;
+ }
+ kdDebug(11001) << "-----------------------------------------------------------" << endl;
+}
+
+#include "kgamepropertyhandler.moc"