X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=904768d5843b7d88a611d9731b454085c976f705;hp=3238f79ce3468efb55ab7f58a760ed0181f2330f;hb=924e2c01204da172a071d34485936b379372e497;hpb=b30780406eabbcfdc313721e961ef063ab06c8d4

diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp
index 3238f79c..904768d5 100644
--- a/src/common/signalproxy.cpp
+++ b/src/common/signalproxy.cpp
@@ -1,26 +1,22 @@
-/****************************************************************************
- **
- ** Copyright (C) Qxt Foundation. Some rights reserved.
- **
- ** This file is part of the QxtNetwork module of the Qt eXTension library
- **
- ** This library is free software; you can redistribute it and/or modify it
- ** under the terms of th Common Public License, version 1.0, as published by
- ** IBM.
- **
- ** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
- ** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
- ** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
- ** FITNESS FOR A PARTICULAR PURPOSE.
- **
- ** You should have received a copy of the CPL along with this file.
- ** See the LICENSE file and the cpl1.0.txt file included with the source
- ** distribution for more information. If you did not receive a copy of the
- ** license, contact the Qxt Foundation.
- **
- ** <http://libqxt.sourceforge.net>  <foundation@libqxt.org>
- **
- ****************************************************************************/
+/***************************************************************************
+ *   Copyright (C) 2005-07 by the Quassel IRC Team                         *
+ *   devel@quassel-irc.org                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program 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 General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
 
 #include "signalproxy.h"
 #include <QObject>
@@ -32,46 +28,69 @@
 #include <QSet>
 #include <QDebug>
 #include <QMetaMethod>
+#include <QMetaProperty>
+#include <QRegExp>
+#include "util.h"
 
-class ClassIntrospector: public QObject {
-// This class MANUALLY implements the necessary parts of QObject.
-// Do NOT add the Q_OBJECT macro. As this class isn't intended
-// for direct use, it doesn't offer any sort of useful meta-object.
+class SignalRelay: public QObject {
+
+/* Q_OBJECT is not necessary or even allowed, because we implement
+   qt_metacall ourselves (and don't use any other features of the meta
+   object system)
+*/
 public:
-  ClassIntrospector(SignalProxy* parent, QObject* source);
+  SignalRelay(SignalProxy* parent, QObject* source);
   int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
 
   void attachSignal(int methodId, const QByteArray &func);
+
+  void setSynchronize(bool);
+  bool synchronize() const;
+  
+  int sigCount() const;
   
 private:
   SignalProxy* proxy;
   QObject* caller;
-  QMultiHash<int, QByteArray> rpcFunction;
+  QMultiHash<int, QByteArray> sigNames;
+  bool _sync;
 };
 
-ClassIntrospector::ClassIntrospector(SignalProxy* parent, QObject* source)
+SignalRelay::SignalRelay(SignalProxy* parent, QObject* source)
   : QObject(parent),
     proxy(parent),
-    caller(source)
+    caller(source),
+    _sync(false)
 {
   QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender()));
 }
 
-int ClassIntrospector::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
+int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
   _id = QObject::qt_metacall(_c, _id, _a);
   if(_id < 0)
     return _id;
   if(_c == QMetaObject::InvokeMetaMethod) {
-    if(rpcFunction.contains(_id)) {
+    if(sigNames.contains(_id) || synchronize()) {
       const QList<int> &argTypes = proxy->argTypes(caller, _id);
       QVariantList params;
       int n = argTypes.size();
       for(int i=0; i<n; i++)
-	params.append(QVariant(argTypes[i], _a[i+1]));
-      QMultiHash<int, QByteArray>::const_iterator funcIter = rpcFunction.constFind(_id);
-      while(funcIter != rpcFunction.constEnd() && funcIter.key() == _id) {
-	proxy->call(funcIter.value(), params);
-	funcIter++;
+        params.append(QVariant(argTypes[i], _a[i+1]));
+      QMultiHash<int, QByteArray>::const_iterator funcIter = sigNames.constFind(_id);
+      while(funcIter != sigNames.constEnd() && funcIter.key() == _id) {
+        proxy->dispatchSignal(funcIter.value(), params);
+        funcIter++;
+      }
+      if(synchronize() && proxy->syncMap(caller).contains(_id)) {
+	// qDebug() << "__SYNC__ >>>"
+	// 	 << caller->metaObject()->className()
+	// 	 << caller->objectName()
+	// 	 << proxy->methodName(caller, _id)
+	// 	 << params;
+	params.prepend(QVariant(_id));
+	params.prepend(caller->objectName());
+	params.prepend(caller->metaObject()->className());
+	proxy->dispatchSignal((int)SignalProxy::Sync, params);
       }
     }
     _id -= 1;
@@ -79,10 +98,35 @@ int ClassIntrospector::qt_metacall(QMetaObject::Call _c, int _id, void **_a) {
   return _id;
 }
 
-void ClassIntrospector::attachSignal(int methodId, const QByteArray &func) {
+void SignalRelay::setSynchronize(bool sync) {
+  QHash<int, int>::const_iterator iter = proxy->syncMap(caller).constBegin();
+  if(!_sync && sync) {
+    while(iter != proxy->syncMap(caller).constEnd()) {
+      QMetaObject::connect(caller, iter.key(), this, QObject::staticMetaObject.methodCount() + iter.key());
+      iter++;
+    }
+  } else if (_sync && !sync) {
+    while(iter != proxy->syncMap(caller).constEnd()) {
+      QMetaObject::disconnect(caller, iter.key(), this, QObject::staticMetaObject.methodCount() + iter.key());
+      iter++;
+    }
+  }
+  _sync = sync;
+}
+
+bool SignalRelay::synchronize() const {
+  return _sync;
+}
+
+int SignalRelay::sigCount() const {
+  // only for debuging purpose
+  return sigNames.count();
+}
+
+void SignalRelay::attachSignal(int methodId, const QByteArray &func) {
   // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
   // all connected methodIds are offset by the standard methodCount of QObject
-  if(!rpcFunction.contains(methodId))
+  if(!sigNames.contains(methodId))
     QMetaObject::connect(caller, methodId, this, QObject::staticMetaObject.methodCount() + methodId);
 
   QByteArray fn;
@@ -91,10 +135,10 @@ void ClassIntrospector::attachSignal(int methodId, const QByteArray &func) {
   } else {
     fn = QByteArray("2") + caller->metaObject()->method(methodId).signature();
   }
-  rpcFunction.insert(methodId, fn);
+  sigNames.insert(methodId, fn);
 }
 // ====================
-// END INTROSPECTOR
+// END SIGNALRELAY
 // ====================
 
 
@@ -102,57 +146,53 @@ void ClassIntrospector::attachSignal(int methodId, const QByteArray &func) {
 //  SignalProxy
 // ====================
 SignalProxy::SignalProxy(QObject* parent)
-  : QObject(parent),
-    _rpcType(Peer),
-    _maxClients(-1)
+  : QObject(parent)
 {
+  setProxyMode(Client);
 }
 
-SignalProxy::SignalProxy(RPCTypes type, QObject* parent)
-  : QObject(parent),
-    _rpcType(type),
-    _maxClients(-1)
+SignalProxy::SignalProxy(ProxyMode mode, QObject* parent)
+  : QObject(parent)
 {
+  setProxyMode(mode);
 }
 
-SignalProxy::SignalProxy(RPCTypes type, QIODevice* device, QObject* parent)
-  : QObject(parent),
-    _rpcType(type),
-    _maxClients(-1)
+SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent)
+  : QObject(parent)
 {
+  setProxyMode(mode);
   addPeer(device);
-}  
+} 
 
 SignalProxy::~SignalProxy() {
-  QList<QObject*> senders = _specHash.keys();
+  QList<QObject*> senders = _relayHash.keys();
   foreach(QObject* sender, senders)
     detachObject(sender);
 }
 
-void SignalProxy::setRPCType(RPCTypes type) {
+void SignalProxy::setProxyMode(ProxyMode mode) {
   foreach(QIODevice* peer, _peerByteCount.keys()) {
     if(peer->isOpen()) {
-      qWarning() << "SignalProxy: Cannot change RPC types while connected";
+      qWarning() << "SignalProxy: Cannot change proxy mode while connected";
       return;
     }
   }
-  _rpcType = type;
+  _proxyMode = mode;
+  if(mode == Server)
+    initServer();
+  else
+    initClient();
 }
 
-
-SignalProxy::RPCTypes SignalProxy::rpcType() const {
-  return (RPCTypes)(_rpcType);
+SignalProxy::ProxyMode SignalProxy::proxyMode() const {
+  return _proxyMode;
 }
 
-bool SignalProxy::maxPeersReached() {
-  if(_peerByteCount.empty())
-    return false;
-  if(rpcType() != Server)
-    return true;
-  if(_maxClients == -1)
-    return false;
+void SignalProxy::initServer() {
+}
 
-  return (_maxClients <= _peerByteCount.count());
+void SignalProxy::initClient() {
+  attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray, QString, QString)));
 }
 
 bool SignalProxy::addPeer(QIODevice* iodev) {
@@ -162,17 +202,17 @@ bool SignalProxy::addPeer(QIODevice* iodev) {
   if(_peerByteCount.contains(iodev))
     return true;
 
-  if(maxPeersReached()) {
-    qWarning("SignalProxy: max peercount reached");
+  if(proxyMode() == Client && !_peerByteCount.isEmpty()) {
+    qWarning("SignalProxy: only one peer allowed in client mode!");
     return false;
   }
-     
+
   if(!iodev->isOpen())
     qWarning("SignalProxy::the device you passed is not open!");
-  
+
   connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender()));
   connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
-  
+
   QAbstractSocket* sock  = qobject_cast<QAbstractSocket*>(iodev);
   if(sock) {
     connect(sock, SIGNAL(disconnected()), this, SLOT(removePeerBySender()));
@@ -182,7 +222,7 @@ bool SignalProxy::addPeer(QIODevice* iodev) {
 
   if(_peerByteCount.count() == 1)
     emit connected();
-  
+
   return true;
 }
 
@@ -192,24 +232,43 @@ void SignalProxy::removePeerBySender() {
   removePeer(ioDev);
 }
 
+void SignalProxy::objectRenamed(QString oldname, QString newname) {
+  const QMetaObject *meta = sender()->metaObject();
+  const QByteArray className(meta->className());
+  objectRenamed(className, oldname, newname);
+
+  if(proxyMode() == Client)
+    return;
+  
+  QVariantList params;
+  params << className << oldname << newname;
+  dispatchSignal("__objectRenamed__", params);
+}
+
+void SignalProxy::objectRenamed(QByteArray classname, QString oldname, QString newname) {
+  if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname))
+    _syncSlave[classname][newname] = _syncSlave[classname].take(oldname);
+}
+
+
 void SignalProxy::removePeer(QIODevice* iodev) {
   if(_peerByteCount.isEmpty()) {
-    qWarning() << "No Peers in use!";
+    qWarning() << "SignalProxy: No peers in use!";
     return;
   }
-     
-  if(_rpcType == Server && !iodev) {
+
+  if(proxyMode() == Server && !iodev) {
     // disconnect all
     QList<QIODevice *> peers = _peerByteCount.keys();
     foreach(QIODevice *peer, peers)
       removePeer(peer);
   }
 
-  if(_rpcType != Server && !iodev)
+  if(proxyMode() != Server && !iodev)
     iodev = _peerByteCount.keys().first();
-  
+
   Q_ASSERT(iodev);
-     
+
   if(!_peerByteCount.contains(iodev)) {
     qWarning() << "SignalProxy: unknown QIODevice" << iodev;
     return;
@@ -219,7 +278,7 @@ void SignalProxy::removePeer(QIODevice* iodev) {
   while(true) {
     QVariant var;
     if(readDataFromDevice(iodev, _peerByteCount[iodev], var))
-      receivePeerSignal(var);
+      receivePeerSignal(iodev, var);
     else
       break;
   }
@@ -233,85 +292,121 @@ void SignalProxy::removePeer(QIODevice* iodev) {
 }
 
 void SignalProxy::setArgTypes(QObject* obj, int methodId) {
-  QList<QByteArray> p = obj->metaObject()->method(methodId).parameterTypes();
+  const QMetaObject *meta = obj->metaObject();
+  QList<QByteArray> p = meta->method(methodId).parameterTypes();
   QList<int> argTypes;
   int ct = p.count();
   for(int i=0; i<ct; i++)
     argTypes.append(QMetaType::type(p.value(i)));
 
-  const QByteArray &className(obj->metaObject()->className());
-  Q_ASSERT(_classInfo.contains(className));
-  Q_ASSERT(!_classInfo[className]->argTypes.contains(methodId));
-  _classInfo[className]->argTypes[methodId] = argTypes;
+  Q_ASSERT(!_classInfo[meta]->argTypes.contains(methodId));
+  _classInfo[meta]->argTypes[methodId] = argTypes;
 }
 
 const QList<int> &SignalProxy::argTypes(QObject *obj, int methodId) {
-  const QByteArray &className(obj->metaObject()->className());
-  Q_ASSERT(_classInfo.contains(className));
-  if(!_classInfo[className]->argTypes.contains(methodId))
+  Q_ASSERT(_classInfo.contains(obj->metaObject()));
+  if(!_classInfo[obj->metaObject()]->argTypes.contains(methodId))
     setArgTypes(obj, methodId);
-  return _classInfo[className]->argTypes[methodId];
+  return _classInfo[obj->metaObject()]->argTypes[methodId];
 }
 
 void SignalProxy::setMethodName(QObject *obj, int methodId) {
-  const QByteArray &className(obj->metaObject()->className());
-  QByteArray method = obj->metaObject()->method(methodId).signature();
-  method = method.left(method.indexOf('('));
-
-  Q_ASSERT(_classInfo.contains(className));
-  Q_ASSERT(!_classInfo[className]->methodNames.contains(methodId));
-  _classInfo[className]->methodNames[methodId] = method;
+  const QMetaObject *meta = obj->metaObject();
+  QByteArray method(::methodName(meta->method(methodId)));
+  Q_ASSERT(!_classInfo[meta]->methodNames.contains(methodId));
+  _classInfo[meta]->methodNames[methodId] = method;
 }
 
 const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) {
-  QByteArray className(obj->metaObject()->className());
-  Q_ASSERT(_classInfo.contains(className));
-  if(!_classInfo[className]->methodNames.contains(methodId))
+  Q_ASSERT(_classInfo.contains(obj->metaObject()));
+  if(!_classInfo[obj->metaObject()]->methodNames.contains(methodId))
     setMethodName(obj, methodId);
-  return _classInfo[className]->methodNames[methodId];
+  return _classInfo[obj->metaObject()]->methodNames[methodId];
 }
 
 
+void SignalProxy::setSyncMap(QObject *obj) {
+  const QMetaObject *meta = obj->metaObject();
+
+  QHash<int, int> syncMap;
+  
+  QList<int> slotIndexes;
+  for(int i = 0; i < meta->methodCount(); i++) {
+    if(meta->method(i).methodType() == QMetaMethod::Slot)
+      slotIndexes << i;
+  }
+
+  QMetaMethod signal, slot;
+  int matchIdx;
+  for(int signalIdx = 0; signalIdx < meta->methodCount(); signalIdx++) {
+    signal = meta->method(signalIdx);
+    if(signal.methodType() != QMetaMethod::Signal)
+      continue;
+
+    matchIdx = -1;
+    foreach(int slotIdx, slotIndexes) {
+      slot = meta->method(slotIdx);
+      if(methodsMatch(signal, slot)) {
+	matchIdx = slotIdx;
+	break;
+      }
+    }
+    if(matchIdx != -1) {
+      slotIndexes.removeAt(slotIndexes.indexOf(matchIdx));
+      syncMap[signalIdx] = matchIdx;
+    }
+  }
+
+  Q_ASSERT(_classInfo[meta]->syncMap.isEmpty());
+  _classInfo[meta]->syncMap = syncMap;
+}
+
+const QHash<int,int> &SignalProxy::syncMap(QObject *obj) {
+  Q_ASSERT(_classInfo.contains(obj->metaObject()));
+  if(_classInfo[obj->metaObject()]->syncMap.isEmpty())
+    setSyncMap(obj);
+  return _classInfo[obj->metaObject()]->syncMap;
+}
+
 void SignalProxy::createClassInfo(QObject *obj) {
-  QByteArray className(obj->metaObject()->className());
-  if(!_classInfo.contains(className))
-    _classInfo[className] = new ClassInfo();
+  if(!_classInfo.contains(obj->metaObject()))
+    _classInfo[obj->metaObject()] = new ClassInfo();
 }
 
-bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& rpcFunction) {
+bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) {
   const QMetaObject* meta = sender->metaObject();
   QByteArray sig(meta->normalizedSignature(signal).mid(1));
   int methodId = meta->indexOfMethod(sig.constData());
   if(methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) {
-    qWarning() << "SignalProxy::attachSignal: No such signal " << signal;
+    qWarning() << "SignalProxy::attachSignal(): No such signal" << signal;
     return false;
   }
 
   createClassInfo(sender);
 
-  ClassIntrospector* spec;
-  if(_specHash.contains(sender))
-    spec = _specHash[sender];
+  SignalRelay* relay;
+  if(_relayHash.contains(sender))
+    relay = _relayHash[sender];
   else
-    spec = _specHash[sender] = new ClassIntrospector(this, sender);
+    relay = _relayHash[sender] = new SignalRelay(this, sender);
 
-  spec->attachSignal(methodId, rpcFunction);
+  relay->attachSignal(methodId, sigName);
 
   return true;
 }
 
 
-bool SignalProxy::attachSlot(const QByteArray& rpcFunction, QObject* recv, const char* slot) {
+bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const char* slot) {
   const QMetaObject* meta = recv->metaObject();
   int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1));
   if(methodId == -1 || meta->method(methodId).methodType() == QMetaMethod::Method) {
-    qWarning() << "SignalProxy::attachSlot: No such slot " << slot;
+    qWarning() << "SignalProxy::attachSlot(): No such slot" << slot;
     return false;
   }
 
   createClassInfo(recv);
-  
-  QByteArray funcName = QMetaObject::normalizedSignature(rpcFunction.constData());
+
+  QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData());
   _attachedSlots.insert(funcName, qMakePair(recv, methodId));
 
   QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender()));
@@ -319,14 +414,71 @@ bool SignalProxy::attachSlot(const QByteArray& rpcFunction, QObject* recv, const
   return true;
 }
 
+void SignalProxy::synchronize(QObject *obj) {
+  if(proxyMode() == Server)
+    return synchronizeAsMaster(obj);
+  else
+    return synchronizeAsSlave(obj);
+}
+
+void SignalProxy::synchronizeAsMaster(QObject *sender) {
+  createClassInfo(sender);
+
+  SignalRelay* relay;
+  if(_relayHash.contains(sender))
+    relay = _relayHash[sender];
+  else
+    relay = _relayHash[sender] = new SignalRelay(this, sender);
+
+  relay->setSynchronize(true);
+
+  if(sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1)
+    connect(sender, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)));
+
+  QByteArray className(sender->metaObject()->className());
+  _syncSlave[className][sender->objectName()] = sender;
+
+  setInitialized(sender);
+}
+
+void SignalProxy::synchronizeAsSlave(QObject *receiver) {
+  QByteArray className(receiver->metaObject()->className());
+  _syncSlave[className][receiver->objectName()] = receiver;
+  
+  createClassInfo(receiver);
+
+  requestInit(receiver);
+}
+
+void SignalProxy::setInitialized(QObject *obj) {
+  QMetaObject::invokeMethod(obj, "setInitialized");
+}
+
+bool SignalProxy::initialized(QObject *obj) {
+  bool init;
+  if(!QMetaObject::invokeMethod(obj, "initialized", Q_RETURN_ARG(bool, init)))
+    init = false;
+  return init;
+}
+
+void SignalProxy::requestInit(QObject *obj) {
+  if(proxyMode() == Server || initialized(obj))
+    return;
+
+  QVariantList params;
+  params << obj->metaObject()->className()
+	 << obj->objectName();
+  dispatchSignal((int)InitRequest, params);
+}
 
 void SignalProxy::detachSender() {
   // this is a slot so we can bypass the QueuedConnection
+  // and if someone is forcing direct connection in a multithreaded environment he's just nuts...
   _detachSignals(sender());
   _detachSlots(sender());
 }
 
-// detachObject/Signals/Slots() can be called as a result of an incomming call
+// detachObject/Signals/Slots() can be called as a result of an incoming call
 // this might destroy our the iterator used for delivery
 // thus we wrap the actual disconnection by using QueuedConnections
 void SignalProxy::detachObject(QObject* obj) {
@@ -340,18 +492,18 @@ void SignalProxy::detachSignals(QObject* sender) {
 			    Q_ARG(QObject*, sender));
 }
 
-void SignalProxy::_detachSignals(QObject* sender) {
-  if(!_specHash.contains(sender))
-    return;
-  _specHash.take(sender)->deleteLater();
-}
-
 void SignalProxy::detachSlots(QObject* receiver) {
   QMetaObject::invokeMethod(this, "_detachSlots",
 			    Qt::QueuedConnection,
 			    Q_ARG(QObject*, receiver));
 }
 
+void SignalProxy::_detachSignals(QObject* sender) {
+  if(!_relayHash.contains(sender))
+    return;
+  _relayHash.take(sender)->deleteLater();
+}
+
 void SignalProxy::_detachSlots(QObject* receiver) {
   SlotHash::iterator slotIter = _attachedSlots.begin();
   while(slotIter != _attachedSlots.end()) {
@@ -362,62 +514,159 @@ void SignalProxy::_detachSlots(QObject* receiver) {
   }
 }
 
-
-void SignalProxy::call(const char*  signal , QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6, QVariant p7, QVariant p8, QVariant p9) {
-  QByteArray sig=QMetaObject::normalizedSignature(signal);
-  QVariantList params;
-  params << p1 << p2 << p3 << p4 << p5
-	 << p6 << p7 << p8 << p9;
-  call(sig, params);
+void SignalProxy::dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList &params) {
+  QVariantList packedFunc;
+  packedFunc << identifier;
+  packedFunc << params;
+  writeDataToDevice(receiver, QVariant(packedFunc));
 }
 
-void SignalProxy::call(const QByteArray &funcName, const QVariantList &params) {
+void SignalProxy::dispatchSignal(const QVariant &identifier, const QVariantList &params) {
+  // yes I know we have a little code duplication here... it's for the sake of performance
   QVariantList packedFunc;
-  packedFunc << funcName;
+  packedFunc << identifier;
   packedFunc << params;
   foreach(QIODevice* dev, _peerByteCount.keys())
     writeDataToDevice(dev, QVariant(packedFunc));
 }
 
-void SignalProxy::receivePeerSignal(const QVariant &packedFunc) {
+void SignalProxy::receivePeerSignal(QIODevice *sender, const QVariant &packedFunc) {
   QVariantList params(packedFunc.toList());
-  QByteArray funcName = params.takeFirst().toByteArray();
-  int numParams, methodId;
-  QObject* receiver;
 
+  QVariant call = params.takeFirst();
+  if(call.type() != QVariant::Int)
+    return handleSignal(call.toByteArray(), params);
+
+  switch(call.toInt()) {
+  case Sync:
+    return handleSync(params);
+  case InitRequest:
+    return handleInitRequest(sender, params);
+  case InitData:
+    return handleInitData(sender, params);
+  default:
+    qWarning() << "received undefined CallType" << call.toInt();
+    return;
+  }
+}
+
+void SignalProxy::handleSync(QVariantList params) {
+  if(params.count() < 3) {
+    qWarning() << "received invalid Sync call" << params;
+    return;
+  }
+  
+  QByteArray className =params.takeFirst().toByteArray();
+  QString objectName = params.takeFirst().toString();
+  int signalId = params.takeFirst().toInt();
+
+  if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) {
+    qWarning() << "no registered receiver:" << className << objectName << "for Sync call" << signalId << params;
+    return;
+  }
+
+  QObject *receiver = _syncSlave[className][objectName];
+  if(!syncMap(receiver).contains(signalId)) {
+    qWarning() << "received Sync Call with invalid SignalId" << className << objectName << signalId;
+  }
+  int slotId = syncMap(receiver)[signalId];
+  if(!invokeSlot(receiver, slotId, params))
+    qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData());
+}
+
+void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList &params) {
+  if(params.count() != 2) {
+    qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
+	       << params;
+    return;
+  }
+  
+  QByteArray className(params[0].toByteArray());
+  QString objectName(params[1].toString());
+
+  if(!_syncSlave.contains(className)) {
+    qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
+	       << className;
+    return;
+  }
+
+  if(!_syncSlave[className].contains(objectName)) {
+    qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
+	       << className << objectName;
+    return;
+  }
+
+  QObject *obj = _syncSlave[className][objectName];
+
+  QVariantList params_;
+  params_ << obj->metaObject()->className()
+	  << obj->objectName()
+	  << initData(obj);
+
+  dispatchSignal(sender, (int)InitData, params_);
+}
+
+void SignalProxy::handleInitData(QIODevice *sender, const QVariantList &params) {
+  Q_UNUSED(sender)
+  if(params.count() != 3) {
+    qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
+	       << params;
+    return;
+  }
+  
+  QByteArray className(params[0].toByteArray());
+  QString objectName(params[1].toString());
+  QVariantMap propertyMap(params[2].toMap());
+
+  if(!_syncSlave.contains(className)) {
+    qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
+	       << className;
+    return;
+  }
+
+  if(!_syncSlave[className].contains(objectName)) {
+    qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
+	       << className << objectName;
+    return;
+  }
+
+  QObject *obj = _syncSlave[className][objectName];
+  setInitData(obj, propertyMap);
+}
+
+void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &params) {
+  QObject* receiver;
+  int methodId;
   SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
   while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
     receiver = (*slot).first;
     methodId = (*slot).second;
-    numParams = argTypes(receiver, methodId).count();
-    QGenericArgument args[9];
-    for(int i = 0; i < numParams; i++)
-      args[i] = QGenericArgument(params[i].typeName(), params[i].constData());
-    if(!QMetaObject::invokeMethod(receiver, methodName(receiver, methodId),
-				  args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8])) {
-      qWarning("SignalProxy::receivePeerSignal: invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
-    }
+    if(!invokeSlot(receiver, methodId, params))
+      qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
     slot++;
   }
 }
 
+bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params) {
+  int numParams = argTypes(receiver, methodId).count();
+  QGenericArgument args[9];
+  for(int i = 0; i < numParams; i++)
+    args[i] = QGenericArgument(params[i].typeName(), params[i].constData());
+  return QMetaObject::invokeMethod(receiver, methodName(receiver, methodId), args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
+}
+
 void SignalProxy::dataAvailable() {
+  // yet again. it's a private slot. no need for checks.
   QIODevice* ioDev = qobject_cast<QIODevice* >(sender());
-  Q_ASSERT(ioDev);
-  if(!_peerByteCount.contains(ioDev)) {
-    qWarning() << "SignalProxy: Unrecognized client object connected to dataAvailable";
-    return;
-  } else {
-    QVariant var;
-    while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
-      receivePeerSignal(var);
-  }
+  QVariant var;
+  while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
+    receivePeerSignal(ioDev, var);
 }
 
 void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item) {
   QAbstractSocket* sock  = qobject_cast<QAbstractSocket*>(dev);
   if(!dev->isOpen() || (sock && sock->state()!=QAbstractSocket::ConnectedState)) {
-    qWarning("can't call on a closed device");
+    qWarning("SignalProxy: Can't call on a closed device");
     return;
   }
   QByteArray block;
@@ -445,4 +694,121 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian
   return true;
 }
 
+bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const {
+  // if we don't even have the same basename it's a sure NO
+  if(methodBaseName(signal) != methodBaseName(slot))
+    return false;
+
+  // are the signatures compatible?
+  if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature()))
+    return false;
+
+  // we take an educated guess if the signals and slots match
+  QString signalsuffix = ::methodName(signal).mid(QString(::methodName(signal)).lastIndexOf(QRegExp("[A-Z]"))).toLower();
+  QString slotprefix = ::methodName(slot).left(QString(::methodName(slot)).indexOf(QRegExp("[A-Z]"))).toLower();
+
+  uint sizediff = qAbs(slotprefix.size() - signalsuffix.size());
+  int ratio = editingDistance(slotprefix, signalsuffix) - sizediff;
+  return (ratio < 2);
+}
+
+QString SignalProxy::methodBaseName(const QMetaMethod &method) {
+  QString methodname = QString(method.signature()).section("(", 0, 0);
+
+  // determine where we have to chop:
+  if(method.methodType() == QMetaMethod::Slot) {
+    // we take evertyhing from the first uppercase char if it's slot
+    methodname = methodname.mid(methodname.indexOf(QRegExp("[A-Z]")));
+  } else {
+    // and if it's a signal we discard everything from the last uppercase char
+    methodname = methodname.left(methodname.lastIndexOf(QRegExp("[A-Z]")));
+  }
+
+  methodname[0] = methodname[0].toUpper();
+
+  return methodname;
+}
+
+QVariantMap SignalProxy::initData(QObject *obj) const {
+  QVariantMap properties;
+
+  const QMetaObject* meta = obj->metaObject();
+
+  // we collect data from properties
+  for(int i = 0; i < meta->propertyCount(); i++) {
+    QMetaProperty prop = meta->property(i);
+    properties[QString(prop.name())] = prop.read(obj);
+  }
+
+  // ...as well as methods, which have names starting with "init"
+  for(int i = 0; i < meta->methodCount(); i++) {
+    QMetaMethod method = meta->method(i);
+    QString methodname(::methodName(method));
+    if(!methodname.startsWith("init") || methodname.startsWith("initSet"))
+      continue;
+
+    QVariant value = QVariant(QVariant::nameToType(method.typeName()));
+    QGenericReturnArgument genericvalue = QGenericReturnArgument(method.typeName(), &value);
+    QMetaObject::invokeMethod(obj, methodname.toAscii(), genericvalue);
+
+    properties[methodBaseName(method)] = value;
+    // qDebug() << ">>> SYNC:" << methodBaseName(method) << value;
+  }
+  
+  // properties["Payload"] = QByteArray(10000000, 'a');  // for testing purposes
+  return properties;
+}
+
+void SignalProxy::setInitData(QObject *obj, const QVariantMap &properties) {
+  if(initialized(obj))
+    return;
+
+  const QMetaObject *meta = obj->metaObject();
+  
+  QVariantMap::const_iterator iterator = properties.constBegin();
+  while(iterator != properties.constEnd()) {
+    QString name = iterator.key();
+    int propertyIndex = meta->indexOfProperty(name.toAscii());
+
+    if(propertyIndex == -1 || !meta->property(propertyIndex).isWritable())
+      setInitValue(obj, name, iterator.value());
+    else
+      obj->setProperty(name.toAscii(), iterator.value());
+    // qDebug() << "<<< SYNC:" << name << iterator.value();
+    iterator++;
+  }
+  setInitialized(obj);
+}
+
+bool SignalProxy::setInitValue(QObject *obj, const QString &property, const QVariant &value) {
+  QString handlername = QString("initSet") + property;
+  handlername[7] = handlername[7].toUpper();
+  QGenericArgument param(value.typeName(), value.constData());
+  return QMetaObject::invokeMethod(obj, handlername.toAscii(), param);
+}
+
+void SignalProxy::dumpProxyStats() {
+  QString mode;
+  if(proxyMode() == Server)
+    mode = "Server";
+  else
+    mode = "Client";
+
+  int sigCount = 0;
+  foreach(SignalRelay *relay, _relayHash.values())
+    sigCount += relay->sigCount();
+
+  int slaveCount = 0;
+  foreach(ObjectId oid, _syncSlave.values())
+    slaveCount += oid.count();
+  
+  qDebug() << this;
+  qDebug() << "              Proxy Mode:" << mode;
+  qDebug() << "attached sending Objects:" << _relayHash.count();
+  qDebug() << "       number of Signals:" << sigCount;
+  qDebug() << "          attached Slots:" << _attachedSlots.count();
+  qDebug() << " number of synced Slaves:" << slaveCount;
+  qDebug() << "number of Classes cached:" << _classInfo.count();
+}
+