X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=50010607604019fcd214890ee75dc5a6f33de128;hp=ebc4ae76e92fb70ea9263b3cd7ccb8a610fe9ee2;hb=a7f5d6a23f7214b11f6db85346a67fd7d02767da;hpb=0ff076706c3d353ec9b098b1eca270195288774e

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index ebc4ae76..50010607 100644
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -34,11 +34,13 @@
 #include <QList>
 #include <QHash>
 #include <QVariant>
+#include <QVariantMap>
 #include <QPair>
 #include <QString>
 #include <QByteArray>
 
 class SignalRelay;
+class QMetaObject;
 
 class SignalProxy : public QObject {
   Q_OBJECT
@@ -49,9 +51,15 @@ public:
     Client
   };
 
-  SignalProxy(QObject* parent);
-  SignalProxy(ProxyMode mode, QObject* parent);
-  SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent);
+  enum RequestType {
+    Sync = 0,
+    InitRequest,
+    InitData
+  };
+
+  SignalProxy(QObject *parent);
+  SignalProxy(ProxyMode mode, QObject *parent);
+  SignalProxy(ProxyMode mode, QIODevice *device, QObject *parent);
   virtual ~SignalProxy();
 
   void setProxyMode(ProxyMode mode);
@@ -60,29 +68,36 @@ public:
   bool addPeer(QIODevice *iodev);
   void removePeer(QIODevice *iodev = 0);
 
-  bool attachSignal(QObject* sender, const char* signal, const QByteArray& sigName = QByteArray());
-  bool attachSlot(const QByteArray& sigName, QObject* recv, const char* slot);
+  bool attachSignal(QObject *sender, const char *signal, const QByteArray& sigName = QByteArray());
+  bool attachSlot(const QByteArray& sigName, QObject *recv, const char *slot);
+
+  void synchronize(QObject *obj);
+  void synchronizeAsMaster(QObject *obj);
+  void synchronizeAsSlave(QObject *obj);
 
+  void setInitialized(QObject *obj);
+  bool initialized(QObject *obj);
+  void requestInit(QObject *obj);
+  
   void detachObject(QObject *obj);
   void detachSignals(QObject *sender);
   void detachSlots(QObject *receiver);
   
-  void call(const char *signal , QVariant p1, QVariant p2, QVariant p3, QVariant p4,
-	    QVariant p5, QVariant p6, QVariant p7, QVariant p8, QVariant p9);
-  void call(const QByteArray &funcName, const QVariantList &params);
-
   static void writeDataToDevice(QIODevice *dev, const QVariant &item);
   static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item);
+
+  static QString methodBaseName(const QMetaMethod &method);
   
-  const QList<int> &argTypes(QObject* obj, int methodId);
-  const QByteArray &methodName(QObject* obj, int methodId);
-  
+  const QList<int> &argTypes(QObject *obj, int methodId);
+  const QByteArray &methodName(QObject *obj, int methodId);
+  const QHash<int, int> &syncMap(QObject *obj);
+
   typedef QHash<int, QList<int> > ArgHash;
   typedef QHash<int, QByteArray> MethodNameHash;
   struct ClassInfo {
     ArgHash argTypes;
     MethodNameHash methodNames;
-    // QHash<int, int> syncMap
+    QHash<int, int> syncMap;
   };
 
   void dumpProxyStats();
@@ -91,24 +106,45 @@ private slots:
   void dataAvailable();
   void detachSender();
   void removePeerBySender();
+  void objectRenamed(QString oldname, QString newname);
+  void objectRenamed(QByteArray classname, QString oldname, QString newname);
 
 signals:
-  void peerRemoved(QIODevice* obj);
+  void peerRemoved(QIODevice *obj);
   void connected();
   void disconnected();
   
 private:
+  void initServer();
+  void initClient();
+  
   void createClassInfo(QObject *obj);
-  void setArgTypes(QObject* obj, int methodId);
-  void setMethodName(QObject* obj, int methodId);
+  void setArgTypes(QObject *obj, int methodId);
+  void setMethodName(QObject *obj, int methodId);
+  void setSyncMap(QObject *obj);
 
-  void receivePeerSignal(const QVariant &packedFunc);
+  bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const;
+
+  void dispatchSignal(QIODevice *receiver, const QVariant &identifier, const QVariantList &params);
+  void dispatchSignal(const QVariant &identifier, const QVariantList &params);
+  
+  void receivePeerSignal(QIODevice *sender, const QVariant &packedFunc);
+  void handleSync(QVariantList params);
+  void handleInitRequest(QIODevice *sender, const QVariantList &params);
+  void handleInitData(QIODevice *sender, const QVariantList &params);
+  void handleSignal(const QByteArray &funcName, const QVariantList &params);
+
+  bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params);
+
+  QVariantMap initData(QObject *obj) const;
+  void setInitData(QObject *obj, const QVariantMap &properties);
+  bool setInitValue(QObject *obj, const QString &property, const QVariant &value);
 
   void _detachSignals(QObject *sender);
   void _detachSlots(QObject *receiver);
 
   // containg a list of argtypes for fast access
-  QHash<QByteArray, ClassInfo*> _classInfo;
+  QHash<const QMetaObject *, ClassInfo*> _classInfo;
 
   // we use one SignalRelay per QObject
   QHash<QObject*, SignalRelay *> _relayHash;
@@ -117,15 +153,17 @@ private:
   typedef QPair<QObject*, int> MethodId;
   typedef QMultiHash<QByteArray, MethodId> SlotHash;
   SlotHash _attachedSlots;
-  
+
+  // slaves for sync
+  typedef QHash<QString, QObject *> ObjectId;
+  QHash<QByteArray, ObjectId> _syncSlave;
 
   // Hash of used QIODevices
   QHash<QIODevice*, quint32> _peerByteCount;
 
   ProxyMode _proxyMode;
-};
-
-
 
+  friend class SignalRelay;
+};
 
 #endif