* qt/qdbusinterface.h: Rename QDBusRef to QDBusInterfacePtr

        and disable the copy operators. (r533772, r534746)

        * qt/qdbuserror.h: Remove the automatic cast to
          bool. (r533929)

        * qt/qdbusabstractinterface.cpp:
        * qt/qdbusabstractinterface.h: Change the default call mode to
        not use the event loop. Add convenience call() methods that
        take a CallMode parameter. (r534042)

        * qt/qdbusconnection.h: Change the default call mode to not
        use the event loop. (r534042)

        * qt/qdbusinterface.cpp:
        * qt/qdbusinterface.h: Add a method to tell us if the
        interface is valid (since we don't return a null pointer
        anymore) (r534099)

        * qt/qdbusinterface_p.h: Don't crash if metaObject is 0
        (r534101)

        * qt/qdbusinternalfilters.cpp: Decouple the introspection
        function in two so taht we get the chance to introspect
        without having a QDBusMessage (r534102)

        * qt/qdbusbus.h:
        * qt/qdbusconnection.cpp:
        * qt/qdbusconnection_p.h:
        * qt/qdbusintegrator.cpp: Keep a list of our own names to
        avoid a round-trip to the server when attempting to introspect
        one of our own objects. Also make sure the filter functions
        match the empty interface as well. (r534108)
        Don't keep the connection names. Instead, trust the unique
        connection name (r534111)
        Remove event loop usage (r534112)

diff --git a/ChangeLog b/ChangeLog
index 7a07e132b8fa232ddc16de7e9003bce6862eb783..c29fb74650b4bc8e54ea399051e2662e62f9d13b 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,41 @@
+2006-04-29  Thiago Macieira  <thiago.macieira@trolltech.com>
+
+       * qt/qdbusinterface.h: Rename QDBusRef to QDBusInterfacePtr
+        and disable the copy operators. (r533772, r534746)
+
+       * qt/qdbuserror.h: Remove the automatic cast to bool. (r533929)
+
+       * qt/qdbusabstractinterface.cpp:
+       * qt/qdbusabstractinterface.h: Change the default call mode to
+        not use the event loop. Add convenience call() methods that
+        take a CallMode parameter. (r534042)
+
+       * qt/qdbusconnection.h: Change the default call mode to not
+        use the event loop. (r534042)
+
+       * qt/qdbusinterface.cpp:
+       * qt/qdbusinterface.h: Add a method to tell us if the
+       interface is valid (since we don't return a null pointer
+       anymore) (r534099)
+
+       * qt/qdbusinterface_p.h: Don't crash if metaObject is 0
+        (r534101)
+
+       * qt/qdbusinternalfilters.cpp: Decouple the introspection
+        function in two so taht we get the chance to introspect
+        without having a QDBusMessage (r534102)
+
+       * qt/qdbusbus.h:
+       * qt/qdbusconnection.cpp:
+       * qt/qdbusconnection_p.h:
+       * qt/qdbusintegrator.cpp: Keep a list of our own names to
+        avoid a round-trip to the server when attempting to introspect
+        one of our own objects. Also make sure the filter functions
+        match the empty interface as well. (r534108)
+       Don't keep the connection names. Instead, trust the unique
+        connection name (r534111)
+       Remove event loop usage (r534112)
+
 2006-04-29  Thiago Macieira  <thiago.macieira@trolltech.com>
 
        * qt/qdbusintegrator.cpp: Fix assertion failure spotted by

diff --git a/qt/qdbusabstractinterface.cpp b/qt/qdbusabstractinterface.cpp
index 291888fe6db1cd030afacdaf4629441e68f8f36d..eec373a31a2094c14127d86558cb8b0049792189 100644 (file)
--- a/qt/qdbusabstractinterface.cpp
+++ b/qt/qdbusabstractinterface.cpp
@@ -148,7 +148,7 @@ QDBusMessage QDBusAbstractInterface::callWithArgs(const QString& method, const Q
 
     if (mode == AutoDetect) {
         // determine if this a sync or async call
-        mode = UseEventLoop;
+        mode = NoUseEventLoop;
         const QMetaObject *mo = metaObject();
         QByteArray match = method.toLatin1() + '(';
 

diff --git a/qt/qdbusabstractinterface.h b/qt/qdbusabstractinterface.h
index ae80b0a3b9e42d7d9e5f656ba48417480ed93239..23f928a2dc113947f90ca2586388e8a9e70d5182 100644 (file)
--- a/qt/qdbusabstractinterface.h
+++ b/qt/qdbusabstractinterface.h
@@ -69,6 +69,11 @@ public:
     {
         return callWithArgs(m);
     }
+
+    inline QDBusMessage call(CallMode mode, const QString &m)
+    {
+        return callWithArgs(m, QList<QVariant>(), mode);
+    }
     
 #ifndef Q_QDOC
 private:
@@ -152,6 +157,85 @@ public:
              << qvfv(t7) << qvfv(t8);
         return callWithArgs(m, args);
     }
+
+    template<typename T1>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1);
+        return callWithArgs(m, args, mode);
+    }
+
+    template<typename T1, typename T2>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2);
+        return callWithArgs(m, args, mode);
+    }
+
+    template<typename T1, typename T2, typename T3>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2,
+                             const T3 &t3)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2) << qvfv(t3);
+        return callWithArgs(m, args, mode);
+    }
+      
+    template<typename T1, typename T2, typename T3, typename T4>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2,
+                             const T3 &t3, const T4 &t4)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2) << qvfv(t3)
+             << qvfv(t4);
+        return callWithArgs(m, args, mode);
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2,
+                             const T3 &t3, const T4 &t4, const T5 &t5)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2) << qvfv(t3)
+             << qvfv(t4) << qvfv(t5);
+        return callWithArgs(m, args, mode);
+    }
+  
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2,
+                             const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2) << qvfv(t3)
+             << qvfv(t4) << qvfv(t5) << qvfv(t6);
+        return callWithArgs(m, args, mode);
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2,
+                             const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2) << qvfv(t3)
+             << qvfv(t4) << qvfv(t5) << qvfv(t6)
+             << qvfv(t7);
+        return callWithArgs(m, args, mode);
+    }
+
+    template<typename T1, typename T2, typename T3, typename T4, typename T5,
+             typename T6, typename T7, typename T8>
+    inline QDBusMessage call(CallMode mode, const QString &m, const T1 &t1, const T2 &t2,
+                             const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6, const T7 &t7,
+                             const T8 &t8)
+    {
+        QList<QVariant> args;
+        args << qvfv(t1) << qvfv(t2) << qvfv(t3)
+             << qvfv(t4) << qvfv(t5) << qvfv(t6)
+             << qvfv(t7) << qvfv(t8);
+        return callWithArgs(m, args, mode);
+    }
 #endif
 
 protected:

diff --git a/qt/qdbusbus.h b/qt/qdbusbus.h
index ae2720e28982eebd88de9f19dd009e75ed2c21f2..6f0bbb1ce87a87856bcd52b4e5344caf2fccccdb 100644 (file)
--- a/qt/qdbusbus.h
+++ b/qt/qdbusbus.h
@@ -150,7 +150,7 @@ public slots:
 signals:
     void nameAcquired(const QString &service);
     void nameLost(const QString &service);
-    void nameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner);    
+    void nameOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner);
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusBusService::RequestNameOptions);

diff --git a/qt/qdbusconnection.h b/qt/qdbusconnection.h
index 60116e1047e4089e75bf1927b9edca339fedd2f0..e107242b3b231f3ff4f8b4a66caaa9d52d0dcaf1 100644 (file)
--- a/qt/qdbusconnection.h
+++ b/qt/qdbusconnection.h
@@ -74,7 +74,7 @@ public:
     QDBusError lastError() const;
 
     bool send(const QDBusMessage &message) const;
-    QDBusMessage sendWithReply(const QDBusMessage &message, WaitMode mode = UseEventLoop) const;
+    QDBusMessage sendWithReply(const QDBusMessage &message, WaitMode mode = NoUseEventLoop) const;
     int sendWithReplyAsync(const QDBusMessage &message, QObject *receiver,
                            const char *slot) const;
 

diff --git a/qt/qdbusconnection_p.h b/qt/qdbusconnection_p.h
index 36f21db7446bb83ddba7ebd76b393d01fe310b3c..af572084ba306e31d4819cd91b4fa750820a25bb 100644 (file)
--- a/qt/qdbusconnection_p.h
+++ b/qt/qdbusconnection_p.h
@@ -230,6 +230,7 @@ extern int qDBusNameToTypeId(const char *name);
 extern bool qDBusCheckAsyncTag(const char *tag);
 
 // in qdbusinternalfilters.cpp
+extern QString qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node);
 extern void qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node,
                                   const QDBusMessage &msg);
 extern void qDBusPropertyGet(const QDBusConnectionPrivate::ObjectTreeNode *node,

diff --git a/qt/qdbusintegrator.cpp b/qt/qdbusintegrator.cpp
index bef8268dda30591dcc29c01a07de6d868af9710a..3f90725690187259f57f01bd73f4b484c9d3ea6b 100644 (file)
--- a/qt/qdbusintegrator.cpp
+++ b/qt/qdbusintegrator.cpp
@@ -984,13 +984,14 @@ bool QDBusConnectionPrivate::activateInternalFilters(const ObjectTreeNode *node,
 {
     // object may be null
 
-    if (msg.interface() == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) {
+    if (msg.interface().isEmpty() || msg.interface() == QLatin1String(DBUS_INTERFACE_INTROSPECTABLE)) {
         if (msg.method() == QLatin1String("Introspect") && msg.signature().isEmpty())
             qDBusIntrospectObject(node, msg);
         return true;
     }
 
-    if (node->obj && msg.interface() == QLatin1String(DBUS_INTERFACE_PROPERTIES)) {
+    if (node->obj && (msg.interface().isEmpty() ||
+                      msg.interface() == QLatin1String(DBUS_INTERFACE_PROPERTIES))) {
         if (msg.method() == QLatin1String("Get") && msg.signature() == QLatin1String("ss"))
             qDBusPropertyGet(node, msg);
         else if (msg.method() == QLatin1String("Set") && msg.signature() == QLatin1String("ssv"))
@@ -1053,25 +1054,26 @@ bool QDBusConnectionPrivate::activateObject(const ObjectTreeNode *node, const QD
     return false;
 }
 
-bool QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
+template<typename Func>
+static bool applyForObject(QDBusConnectionPrivate::ObjectTreeNode *root, const QString &fullpath,
+                           Func& functor)
 {
-    QReadLocker locker(&lock);
-
     // walk the object tree
-    QStringList path = msg.path().split(QLatin1Char('/'));
+    QStringList path = fullpath.split(QLatin1Char('/'));
     if (path.last().isEmpty())
         path.removeLast();      // happens if path is "/"
     int i = 1;
-    ObjectTreeNode *node = &rootNode;
+    QDBusConnectionPrivate::ObjectTreeNode *node = root;
 
     // try our own tree first
     while (node && !(node->flags & QDBusConnection::ExportChildObjects) ) {
         if (i == path.count()) {
             // found our object
-            return activateObject(node, msg);
+            functor(node);
+            return true;
         }
 
-        QVector<ObjectTreeNode::Data>::ConstIterator it =
+        QVector<QDBusConnectionPrivate::ObjectTreeNode::Data>::ConstIterator it =
             qLowerBound(node->children.constBegin(), node->children.constEnd(), path.at(i));
         if (it != node->children.constEnd() && it->name == path.at(i))
             // match
@@ -1089,9 +1091,10 @@ bool QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
         while (obj) {
             if (i == path.count()) {
                 // we're at the correct level
-                ObjectTreeNode fakenode(*node);
+                QDBusConnectionPrivate::ObjectTreeNode fakenode(*node);
                 fakenode.obj = obj;
-                return activateObject(&fakenode, msg);
+                functor(&fakenode);
+                return true;
             }
 
             const QObjectList &children = obj->children();
@@ -1112,6 +1115,31 @@ bool QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
         }
     }
 
+    // object not found
+    return false;
+}
+
+struct qdbus_activateObject
+{
+    QDBusConnectionPrivate *self;
+    const QDBusMessage &msg;
+    bool returnVal;
+    inline qdbus_activateObject(QDBusConnectionPrivate *s, const QDBusMessage &m)
+        : self(s), msg(m)
+    { }
+
+    inline void operator()(QDBusConnectionPrivate::ObjectTreeNode *node)
+    { returnVal = self->activateObject(node, msg); }
+};
+
+bool QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
+{
+    QReadLocker locker(&lock);
+
+    qdbus_activateObject apply(this, msg);
+    if (applyForObject(&rootNode, msg.path(), apply))
+        return apply.returnVal;
+
     qDebug("Call failed: no object found at %s", qPrintable(msg.path()));
     return false;
 }
@@ -1479,6 +1507,7 @@ QDBusConnectionPrivate::findInterface(const QString &service,
     QString owner = getNameOwner(service);
     if (connection && !owner.isEmpty() && QDBusUtil::isValidObjectPath(path) &&
         (interface.isEmpty() || QDBusUtil::isValidInterfaceName(interface)))
+        // always call here with the unique connection name
         mo = findMetaObject(owner, path, interface);
 
     QDBusInterfacePrivate *p = new QDBusInterfacePrivate(QDBusConnection(name), this, owner, path, interface, mo);
@@ -1509,24 +1538,52 @@ QDBusConnectionPrivate::findInterface(const QString &service,
     return p;
 }
 
+struct qdbus_Introspect
+{
+    QString xml;
+    inline void operator()(QDBusConnectionPrivate::ObjectTreeNode *node)
+    { xml = qDBusIntrospectObject(node); }
+};
+
 QDBusMetaObject *
 QDBusConnectionPrivate::findMetaObject(const QString &service, const QString &path,
                                        const QString &interface)
 {
+    // service must be a unique connection name
     if (!interface.isEmpty()) {
         QReadLocker locker(&lock);
         QDBusMetaObject *mo = cachedMetaObjects.value(interface, 0);
         if (mo)
             return mo;
     }
+    if (service == QString::fromUtf8(dbus_bus_get_unique_name(connection))) {
+        // it's one of our own
+        QWriteLocker locker(&lock);
+        QDBusMetaObject *mo = 0;
+        if (!interface.isEmpty())
+            mo = cachedMetaObjects.value(interface, 0);
+        if (mo)
+            // maybe it got created when we switched from read to write lock
+            return mo;
+
+        qdbus_Introspect apply;
+        if (!applyForObject(&rootNode, path, apply)) {
+            lastError = QDBusError(QDBusError::InvalidArgs,
+                                   QString(QLatin1String("No object at %1")).arg(path));
+            return 0;           // no object at path
+        }
+
+        // release the lock and return
+        return QDBusMetaObject::createMetaObject(interface, apply.xml, cachedMetaObjects, lastError);
+    }
 
-    // introspect the target object:
+    // not local: introspect the target object:
     QDBusMessage msg = QDBusMessage::methodCall(service, path,
                                                 QLatin1String(DBUS_INTERFACE_INTROSPECTABLE),
                                                 QLatin1String("Introspect"));
 
-    // we have to spin the event loop because the call could be targetting ourselves
-    QDBusMessage reply = sendWithReply(msg, QDBusConnection::UseEventLoop);
+
+    QDBusMessage reply = sendWithReply(msg, QDBusConnection::NoUseEventLoop);
 
     // it doesn't exist yet, we have to create it
     QWriteLocker locker(&lock);

diff --git a/qt/qdbusinterface.cpp b/qt/qdbusinterface.cpp
index ff8fdc95fa86f9b4b4512cbf87512e1f929f905e..48b1011c32f75afc2a382cb15f4305c446afff49 100644 (file)
--- a/qt/qdbusinterface.cpp
+++ b/qt/qdbusinterface.cpp
@@ -57,6 +57,19 @@ QDBusInterface::~QDBusInterface()
     // resources are freed in QDBusInterfacePrivate::~QDBusInterfacePrivate()
 }
 
+/*!
+    Returns true if this is a valid reference to a remote object. It returns false if
+    there was an error during the creation of this interface (for instance, if the remote
+    application does not exist).
+
+    Note: when dealing with remote objects, it is not always possible to determine if it
+    exists when creating a QDBusInterface or QDBusInterfacePtr object.
+*/
+bool QDBusInterface::isValid() const
+{
+    return d_func()->isValid;
+}
+
 /*!
     \internal
     Overrides QObject::metaObject to return our own copy.
@@ -238,13 +251,13 @@ int QDBusInterfacePrivate::metacall(QMetaObject::Call c, int id, void **argv)
     return id;
 }
 
-QDBusRef::QDBusRef(QDBusConnection &conn, const QString &service, const QString &path,
+QDBusInterfacePtr::QDBusInterfacePtr(QDBusConnection &conn, const QString &service, const QString &path,
                    const QString &interface)
     : d(conn.findInterface(service, path, interface))
 {
 }
 
-QDBusRef::QDBusRef(const QString &service, const QString &path, const QString &interface)
+QDBusInterfacePtr::QDBusInterfacePtr(const QString &service, const QString &path, const QString &interface)
     : d(QDBus::sessionBus().findInterface(service, path, interface))
 {
 }

diff --git a/qt/qdbusinterface.h b/qt/qdbusinterface.h
index f667698b58db77c8d59853a8168dfd1217a7d485..2e16e5ce736aff920845b62f760bf86f32b18f42 100644 (file)
--- a/qt/qdbusinterface.h
+++ b/qt/qdbusinterface.h
@@ -35,6 +35,8 @@ private:
     
 public:
     ~QDBusInterface();
+    bool isValid() const;
+    
     virtual const QMetaObject *metaObject() const;
     virtual void *qt_metacast(const char *);
     virtual int qt_metacall(QMetaObject::Call, int, void **);
@@ -43,16 +45,19 @@ private:
     Q_DECLARE_PRIVATE(QDBusInterface);
 };
 
-struct QDBUS_EXPORT QDBusRef
+struct QDBUS_EXPORT QDBusInterfacePtr
 {
-    QDBusRef(QDBusConnection &conn, const QString &service, const QString &path,
+    QDBusInterfacePtr(QDBusInterface *iface) : d(iface) { }
+    QDBusInterfacePtr(QDBusConnection &conn, const QString &service, const QString &path,
              const QString &interface = QString());
-    QDBusRef(const QString &service, const QString &path, const QString &interface = QString());
-    ~QDBusRef() { delete d; }
+    QDBusInterfacePtr(const QString &service, const QString &path, const QString &interface = QString());
+    ~QDBusInterfacePtr() { delete d; }
 
-    QDBusInterface* operator->() const { return d; }
+    QDBusInterface *interface() { return d; }
+    QDBusInterface *operator->() { return d; }
 private:
     QDBusInterface *const d;
+    Q_DISABLE_COPY(QDBusInterfacePtr)
 };
 
 #endif

diff --git a/qt/qdbusinterface_p.h b/qt/qdbusinterface_p.h
index 70b732c200ff8683c2759942ac4f2eea08de9f53..25cb9ffaec662c397709b760ce6483c7339c9f42 100644 (file)
--- a/qt/qdbusinterface_p.h
+++ b/qt/qdbusinterface_p.h
@@ -55,7 +55,7 @@ public:
     }
     ~QDBusInterfacePrivate()
     {
-        if (!metaObject->cached)
+        if (metaObject && !metaObject->cached)
             delete metaObject;
     }
 

diff --git a/qt/qdbusinternalfilters.cpp b/qt/qdbusinternalfilters.cpp
index fe57a8750cacb84d3ad6f2983446622bd30b148b..3d4542778958d0a72c54743f77a7763faadb023a 100644 (file)
--- a/qt/qdbusinternalfilters.cpp
+++ b/qt/qdbusinternalfilters.cpp
@@ -225,8 +225,7 @@ static QString generateSubObjectXml(QObject *object)
     return retval;
 }
 
-void qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node,
-                           const QDBusMessage &msg)
+QString qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node)
 {
     // object may be null
 
@@ -281,10 +280,15 @@ void qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node,
     }
 
     xml_data += QLatin1String("</node>\n");
+    return xml_data;
+}
 
+void qDBusIntrospectObject(const QDBusConnectionPrivate::ObjectTreeNode *node,
+                           const QDBusMessage &msg)
+{
     // now send it
     QDBusMessage reply = QDBusMessage::methodReply(msg);
-    reply << xml_data;
+    reply << qDBusIntrospectObject(node);
     msg.connection().send(reply);
 }