Fix license headers: Quassel IRC Team -> Quassel Project, 2007 -> 2008

[quassel.git] / src / common / signalproxy.cpp

diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp
index 841a79f..5393cff 100644 (file)
--- a/src/common/signalproxy.cpp
+++ b/src/common/signalproxy.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-07 by the Quassel IRC Team                         *
+ *   Copyright (C) 2005-08 by the Quassel Project                          *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -51,6 +51,8 @@ public:
   int sigCount() const;
   
 private:
+  bool isSyncMethod(int i);
+  
   SignalProxy* proxy;
   QObject* caller;
   QMultiHash<int, QByteArray> sigNames;
@@ -108,19 +110,33 @@ void SignalRelay::setSynchronize(bool sync) {
   if(!_sync && sync) {
     // enable Sync
     for(int i = 0; i < meta->methodCount(); i++ ) {
-      if(proxy->syncMap(caller).contains(meta->method(i).signature()))
+      if(isSyncMethod(i))
        QMetaObject::connect(caller, i, this, QObject::staticMetaObject.methodCount() + i);
     }
   } else if (_sync && !sync) {
     // disable Sync
     for(int i = 0; i < meta->methodCount(); i++ ) {
-      if(proxy->syncMap(caller).contains(meta->method(i).signature()))
+      if(isSyncMethod(i))
        QMetaObject::disconnect(caller, i, this, QObject::staticMetaObject.methodCount() + i);
     }
   }
   _sync = sync;
 }
 
+bool SignalRelay::isSyncMethod(int i) {
+  QByteArray signature = caller->metaObject()->method(i).signature();
+  if(!proxy->syncMap(caller).contains(signature))
+    return false;
+  
+  if(proxy->proxyMode() == SignalProxy::Server && !signature.startsWith("request"))
+    return true;
+
+  if(proxy->proxyMode() == SignalProxy::Client && signature.startsWith("request"))
+    return true;
+
+  return false;
+}
+
 bool SignalRelay::synchronize() const {
   return _sync;
 }
@@ -318,6 +334,12 @@ const QList<int> &SignalProxy::argTypes(QObject *obj, int methodId) {
   return _classInfo[obj->metaObject()]->argTypes[methodId];
 }
 
+bool SignalProxy::hasUpdateSignal(QObject *obj) {
+  if(!_classInfo.contains(obj->metaObject()))
+    return false;
+  return _classInfo[obj->metaObject()]->hasUpdateSignal;
+}
+
 void SignalProxy::setMethodName(QObject *obj, int methodId) {
   const QMetaObject *meta = obj->metaObject();
   QByteArray method(::methodName(meta->method(methodId)));
@@ -376,8 +398,12 @@ const QHash<QByteArray,int> &SignalProxy::syncMap(QObject *obj) {
 }
 
 void SignalProxy::createClassInfo(QObject *obj) {
-  if(!_classInfo.contains(obj->metaObject()))
-    _classInfo[obj->metaObject()] = new ClassInfo();
+  if(_classInfo.contains(obj->metaObject()))
+    return;
+
+  ClassInfo *classInfo = new ClassInfo();
+  classInfo->hasUpdateSignal = (obj->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("updatedRemotely()")) != -1);
+  _classInfo[obj->metaObject()] = classInfo;
 }
 
 bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) {
@@ -422,39 +448,29 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha
 }
 
 void SignalProxy::synchronize(QObject *obj) {
-  if(proxyMode() == Server)
-    return synchronizeAsMaster(obj);
-  else
-    return synchronizeAsSlave(obj);
-}
-
-void SignalProxy::synchronizeAsMaster(QObject *sender) {
-  createClassInfo(sender);
+  createClassInfo(obj);
 
+  // attaching all the Signals
   SignalRelay* relay;
-  if(_relayHash.contains(sender))
-    relay = _relayHash[sender];
+  if(_relayHash.contains(obj))
+    relay = _relayHash[obj];
   else
-    relay = _relayHash[sender] = new SignalRelay(this, sender);
+    relay = _relayHash[obj] = new SignalRelay(this, obj);
 
   relay->setSynchronize(true);
 
-  if(sender->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1)
-    connect(sender, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)), Qt::DirectConnection);
+  // attaching as slave to receive sync Calls
+  QByteArray className(obj->metaObject()->className());
+  _syncSlave[className][obj->objectName()] = obj;
 
-  QByteArray className(sender->metaObject()->className());
-  _syncSlave[className][sender->objectName()] = sender;
+  if(proxyMode() == Server) {
+    if(obj->metaObject()->indexOfSignal(QMetaObject::normalizedSignature("renameObject(QString, QString)")) != -1)
+      connect(obj, SIGNAL(renameObject(QString, QString)), this, SLOT(objectRenamed(QString, QString)), Qt::DirectConnection);
 
-  setInitialized(sender);
-}
-
-void SignalProxy::synchronizeAsSlave(QObject *receiver) {
-  QByteArray className(receiver->metaObject()->className());
-  _syncSlave[className][receiver->objectName()] = receiver;
-  
-  createClassInfo(receiver);
-
-  requestInit(receiver);
+    setInitialized(obj);
+  } else {
+    requestInit(obj);
+  }
 }
 
 void SignalProxy::setInitialized(QObject *obj) {
@@ -609,8 +625,12 @@ void SignalProxy::handleSync(QVariantList params) {
   }
 
   int slotId = syncMap(receiver)[signal];
-  if(!invokeSlot(receiver, slotId, params))
+  if(!invokeSlot(receiver, slotId, params)) {
     qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData());
+    return;
+  }
+  if(hasUpdateSignal(receiver))
+    QMetaObject::invokeMethod(receiver, "updatedRemotely");
 }
 
 void SignalProxy::handleInitRequest(QIODevice *sender, const QVariantList &params) {