Development/Tutorials/Porting to D-Bus - Revision history

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:58:50Z
Text replace - "<code cpp-qt>" to "<syntaxhighlight lang="cpp-qt">"

				
				
				
				
			
			← Older revision
			Revision as of 20:58, 29 June 2011
			
Line 20:
Line 20:
    
  Sample code in DCOP:   Sample code in DCOP:
− <code cpp-qt> + <syntaxhighlight lang="cpp-qt">
  DCOPRef kded("kded", "favicons")   DCOPRef kded("kded", "favicons")
  DCOPReply reply = kded.call("iconForURL(KUrl)", url);   DCOPReply reply = kded.call("iconForURL(KUrl)", url);
Line 138:
Line 138:
    
  Sample DCOP code:   Sample DCOP code:
− <code cpp-qt> + <syntaxhighlight lang="cpp-qt">
  class MyClass: public QObject, public DCOPObject   class MyClass: public QObject, public DCOPObject
  {   {

`Neverendingo: Text replace - "`" to ""

2011-06-29T20:54:37Z

Text replace - "</code>" to "</syntaxhighlight>"

Neverendingo: Text replace - "`" to ""`


2011-06-29T20:30:19Z
Text replace - "<code cppqt>" to "<syntaxhighlight lang="cpp-qt">"

				
				
				
				
			
			← Older revision
			Revision as of 20:30, 29 June 2011
			
Line 31:
Line 31:
    
  Sample code in D-Bus:   Sample code in D-Bus:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QDBusInterface kded("org.kde.kded", "/modules/favicons",          QDBusInterface kded("org.kde.kded", "/modules/favicons",       
                       "org.kde.FaviconsModule");                        "org.kde.FaviconsModule");
Line 48:
Line 48:
    
  Sample;   Sample;
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QDBusInterface interface("org.kde.myapp", "/MyObject",      QDBusInterface interface("org.kde.myapp", "/MyObject",   
                            "org.kde.MyInterface");                             "org.kde.MyInterface");
Line 67:
Line 67:
  * Remove the k_dcop method references.   * Remove the k_dcop method references.
  * Make the methods that were DCOP-accessible scriptable slots. That is, you must make it:   * Make the methods that were DCOP-accessible scriptable slots. That is, you must make it:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  public Q_SLOTS:   public Q_SLOTS:
       Q_SCRIPTABLE void methodName();        Q_SCRIPTABLE void methodName();
Line 78:
Line 78:
    
  In order to register the object, you'll need to do:   In order to register the object, you'll need to do:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  QDBusConnection::sessionBus().registerObject("<object-path>", this,   QDBusConnection::sessionBus().registerObject("<object-path>", this,
                               QDBusConnection::ExportScriptableSlots);                                QDBusConnection::ExportScriptableSlots);
Line 91:
Line 91:
    
  You'll declare it as:   You'll declare it as:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  class MyAdaptor: public QDBusAbstractAdaptor   class MyAdaptor: public QDBusAbstractAdaptor
  {   {
Line 106:
Line 106:
    
  And the implementation will look like:   And the implementation will look like:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  MyAdaptor::MyAdaptor(QObject *parent)   MyAdaptor::MyAdaptor(QObject *parent)
    : QDBusAbstractAdaptor(parent)     : QDBusAbstractAdaptor(parent)
Line 119:
Line 119:
    
  In the class using the adaptor, do this:   In the class using the adaptor, do this:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  new MyAdaptor(this);   new MyAdaptor(this);
  QDBusConnection::sessionBus().registerObject("/<object-path>", this,   QDBusConnection::sessionBus().registerObject("/<object-path>", this,
Line 165:
Line 165:
    
  The equivalent code with QtDBus would be:   The equivalent code with QtDBus would be:
− <code cppqt> + <syntaxhighlight lang="cpp-qt">
  class MyClass: public QObject, private QDBusContext   class MyClass: public QObject, private QDBusContext
  {   {



Tampakrap at 19:27, 11 July 2009
2009-07-11T19:27:33Z


				
				
				
				
			
			← Older revision
			Revision as of 19:27, 11 July 2009
			
Line 20:
Line 20:
    
  Sample code in DCOP:   Sample code in DCOP:
− <code cppqt3> + <code cpp-qt>
  DCOPRef kded("kded", "favicons")   DCOPRef kded("kded", "favicons")
  DCOPReply reply = kded.call("iconForURL(KUrl)", url);   DCOPReply reply = kded.call("iconForURL(KUrl)", url);
Line 138:
Line 138:
    
  Sample DCOP code:   Sample DCOP code:
− <code cppqt3> + <code cpp-qt>
  class MyClass: public QObject, public DCOPObject   class MyClass: public QObject, public DCOPObject
  {   {





Thiago: Performance improvement: QString(QLatin1String(...)) is stupid
2007-08-30T11:54:43Z
Performance improvement: QString(QLatin1String(...)) is stupid

				
				
				
				
			
			← Older revision
			Revision as of 11:54, 30 August 2007
			
Line 185:
Line 185:
       void processLater()        void processLater()
       {        {
−          reply << QString(QLatin1String("foo")); +          reply << QString::fromLatin1("foo");
           connection.send(reply);            connection.send(reply);
       }        }





Thiago: /* DCOP Transactions */
2007-08-30T11:53:22Z
‎DCOP Transactions

				
				
				
				
			
			← Older revision
			Revision as of 11:53, 30 August 2007
			
Line 174:
Line 174:
       Q_SCRIPTABLE QString myMethod(const QString &arg1)        Q_SCRIPTABLE QString myMethod(const QString &arg1)
       {        {
−          // connection(), message() and setDelayedReply() come from QDBusContext +          // connection(), message() and setDelayedReply()  
  +         // come from QDBusContext
           connection = connection();            connection = connection();
           reply = QDBusMessage::createReply(message());            reply = QDBusMessage::createReply(message());





Thiago: Update to QDBusContext
2007-08-30T11:52:57Z
Update to QDBusContext

				
				
				
				
			
			← Older revision
			Revision as of 11:52, 30 August 2007
			
Line 135:
Line 135:
  DCOP had the capability of doing transactions: that is, delay the reply from a called method until later on. QtDBus has the same functionality, under a different name.   DCOP had the capability of doing transactions: that is, delay the reply from a called method until later on. QtDBus has the same functionality, under a different name.
    
− Unlike DCOP, with QtDBus, you need a special parameter to your slot in order to receive the information about the call and set up the delayed reply. This parameter is of type {{qt|QDBusMessage}} and must appear after the last input parameter. You declare that you want a delayed reply by creating a reply. You will be responsible for sending it later. + Unlike DCOP, with QtDBus, you need to declare that your class may want to do transactions. For that, you must make your object derive from {{qt|QDBusContext}} as well as from your your normal inheritance. This will provide you with a few extra methods in your class. You will want to call setDelayedReply to notify QtDBus that the reply will come at a later point in time. You also want to keep the original connection object and message so as to be able to send the proper reply on the proper connection.
    
  Sample DCOP code:   Sample DCOP code:
Line 166:
Line 166:
  The equivalent code with QtDBus would be:   The equivalent code with QtDBus would be:
  <code cppqt>   <code cppqt>
− class MyClass: public QObject + class MyClass: public QObject, private QDBusContext
  {   {
       QDBusMessage reply;        QDBusMessage reply;
Line 172:
Line 172:
    
  public Q_SLOTS:   public Q_SLOTS:
−      Q_SCRIPTABLE QString myMethod(const QString &arg1, +      Q_SCRIPTABLE QString myMethod(const QString &arg1)
−                                   const QDBusMessage &msg) + 
       {        {
−          connection = QDBusConnection::sender(); +         // connection(), message() and setDelayedReply() come from QDBusContext
−          reply = QDBusMessage::createReply(msg); +          connection = connection();
  +          reply = QDBusMessage::createReply(message());
  +         setDelayedReply(true);
           QTimer::singleShot(0, this, SLOT(processLater());            QTimer::singleShot(0, this, SLOT(processLater());
           return QString();       // reply will be ignored            return QString();       // reply will be ignored





Winterz: descroll
2007-03-07T15:08:33Z
descroll

				
				
				
				
			
			← Older revision
			Revision as of 15:08, 7 March 2007
			
Line 79:
Line 79:
  In order to register the object, you'll need to do:   In order to register the object, you'll need to do:
  <code cppqt>   <code cppqt>
− QDBusConnection::sessionBus().registerObject("<object-path>", this,   + QDBusConnection::sessionBus().registerObject("<object-path>", this,
−                                              QDBusConnection::ExportScriptableSlots); +                             QDBusConnection::ExportScriptableSlots);
  </code>   </code>
    





Pino: use the right classes for code highlighting
2007-03-07T14:37:43Z
use the right classes for code highlighting

				
				
				
				
			
			← Older revision
			Revision as of 14:37, 7 March 2007
			
Line 20:
Line 20:
    
  Sample code in DCOP:   Sample code in DCOP:
− <code cpp> + <code cppqt3>
  DCOPRef kded("kded", "favicons")   DCOPRef kded("kded", "favicons")
  DCOPReply reply = kded.call("iconForURL(KUrl)", url);   DCOPReply reply = kded.call("iconForURL(KUrl)", url);
Line 31:
Line 31:
    
  Sample code in D-Bus:   Sample code in D-Bus:
− <code cpp> + <code cppqt>
  QDBusInterface kded("org.kde.kded", "/modules/favicons",          QDBusInterface kded("org.kde.kded", "/modules/favicons",       
                       "org.kde.FaviconsModule");                        "org.kde.FaviconsModule");
Line 48:
Line 48:
    
  Sample;   Sample;
− <code cpp> + <code cppqt>
  QDBusInterface interface("org.kde.myapp", "/MyObject",      QDBusInterface interface("org.kde.myapp", "/MyObject",   
                            "org.kde.MyInterface");                             "org.kde.MyInterface");
Line 67:
Line 67:
  * Remove the k_dcop method references.   * Remove the k_dcop method references.
  * Make the methods that were DCOP-accessible scriptable slots. That is, you must make it:   * Make the methods that were DCOP-accessible scriptable slots. That is, you must make it:
− <code cpp> + <code cppqt>
  public Q_SLOTS:   public Q_SLOTS:
       Q_SCRIPTABLE void methodName();        Q_SCRIPTABLE void methodName();
Line 78:
Line 78:
    
  In order to register the object, you'll need to do:   In order to register the object, you'll need to do:
− <code cpp> + <code cppqt>
  QDBusConnection::sessionBus().registerObject("<object-path>", this,     QDBusConnection::sessionBus().registerObject("<object-path>", this,  
                                                QDBusConnection::ExportScriptableSlots);                                                 QDBusConnection::ExportScriptableSlots);
Line 91:
Line 91:
    
  You'll declare it as:   You'll declare it as:
− <code cpp> + <code cppqt>
  class MyAdaptor: public QDBusAbstractAdaptor   class MyAdaptor: public QDBusAbstractAdaptor
  {   {
Line 106:
Line 106:
    
  And the implementation will look like:   And the implementation will look like:
− <code cpp> + <code cppqt>
  MyAdaptor::MyAdaptor(QObject *parent)   MyAdaptor::MyAdaptor(QObject *parent)
    : QDBusAbstractAdaptor(parent)     : QDBusAbstractAdaptor(parent)
Line 119:
Line 119:
    
  In the class using the adaptor, do this:   In the class using the adaptor, do this:
− <code cpp> + <code cppqt>
  new MyAdaptor(this);   new MyAdaptor(this);
  QDBusConnection::sessionBus().registerObject("/<object-path>", this,   QDBusConnection::sessionBus().registerObject("/<object-path>", this,
Line 138:
Line 138:
    
  Sample DCOP code:   Sample DCOP code:
− <code cpp> + <code cppqt3>
  class MyClass: public QObject, public DCOPObject   class MyClass: public QObject, public DCOPObject
  {   {
Line 165:
Line 165:
    
  The equivalent code with QtDBus would be:   The equivalent code with QtDBus would be:
− <code cpp> + <code cppqt>
  class MyClass: public QObject   class MyClass: public QObject
  {   {



Thiago: Update to the API found in the released Qt 4.2
2007-03-04T22:58:43Z
Update to the API found in the released Qt 4.2

				
				
				
				
			
			← Older revision
			Revision as of 22:58, 4 March 2007
			
Line 12:
Line 12:
    
  === Converting Calls using DCOPRef and DCOPReply ===   === Converting Calls using DCOPRef and DCOPReply ===
− The direct replacement for {{class|DCOPRef}} is {{qt|QDBusInterfacePtr}}, which is just a wrapper around {{qt|QDBusInterface}}. The replacement for {{qt|QDBusReply}}. + The direct replacement for {{class|DCOPRef}} is {{qt|QDBusInterface}}. The replacement for DCOPReply is {{qt|QDBusReply}}.
    
  However, there are some important differences to be noticed:   However, there are some important differences to be noticed:
Line 32:
Line 32:
  Sample code in D-Bus:   Sample code in D-Bus:
  <code cpp>   <code cpp>
− QDBusInterfacePtr kded("org.kde.kded", "/modules/favicons",        + QDBusInterface kded("org.kde.kded", "/modules/favicons",       
−                        "org.kde.FaviconsModule"); +                     "org.kde.FaviconsModule");
− QDBusReply<QString> reply = kded->call("iconForURL", url.url()); + QDBusReply<QString> reply = kded.call("iconForURL", url.url());
  return reply;   return reply;
  </code>   </code>
    
  Things to note in the code:   Things to note in the code:
− * use the 3-argument version of {{qt|QDBusInterfacePtr}}. The interface name you can usually obtain by calling "interfaces" on the existing DCOP object (in this case, "dcop kded favicons interfaces"). + * use the 3-argument version of {{qt|QDBusInterface}}. The interface name you can usually obtain by calling "interfaces" on the existing DCOP object (in this case, "dcop kded favicons interfaces").
  * the "application id" becomes a "service name" and it should start with "org.kde"   * the "application id" becomes a "service name" and it should start with "org.kde"
  * the "object id" becomes an "object path" and must start with a slash   * the "object id" becomes an "object path" and must start with a slash
− * it's "kded->call", not "kded.call"  
  * you don't write the function signature: just the function name   * you don't write the function signature: just the function name
  * custom types are not supported (nor ever will be), so you need to convert them to basic types   * custom types are not supported (nor ever will be), so you need to convert them to basic types
Line 50:
Line 49:
  Sample;   Sample;
  <code cpp>   <code cpp>
− QDBusInterfacePtr interface("org.kde.myapp", "/MyObject",    + QDBusInterface interface("org.kde.myapp", "/MyObject",   
−                             "org.kde.MyInterface"); +                          "org.kde.MyInterface");
− QDBusMessage reply = interface->call("myFunction", argument1, argument2); + QDBusMessage reply = interface.call("myFunction", argument1, argument2);
  if (reply.type() == QDBusMessage::ReplyMessage)   if (reply.type() == QDBusMessage::ReplyMessage)
  {   {
Line 64:
Line 63:
  There is no direct replacement for {{class|DCOPObject}}. It's replaced by a normal {{qt|QObject}} with explict registering. You may use this new {{qt|QObject}} with or without an adaptor. So, in order to port, you need to follow these steps:   There is no direct replacement for {{class|DCOPObject}}. It's replaced by a normal {{qt|QObject}} with explict registering. You may use this new {{qt|QObject}} with or without an adaptor. So, in order to port, you need to follow these steps:
    
− *Remove the "virtual public DCOPObject" from the class declaration + * Remove the "virtual public DCOPObject" from the class declaration
  * Replace the K_DCOP macro with Q_CLASSINFO("D-Bus Interface", "<interfacename>") where <interfacename> is the name of the interface you're declaring (generally, it'll be "org.kde" followed by the class name itself)   * Replace the K_DCOP macro with Q_CLASSINFO("D-Bus Interface", "<interfacename>") where <interfacename> is the name of the interface you're declaring (generally, it'll be "org.kde" followed by the class name itself)
  * Remove the k_dcop method references.   * Remove the k_dcop method references.
Line 80:
Line 79:
  In order to register the object, you'll need to do:   In order to register the object, you'll need to do:
  <code cpp>   <code cpp>
− QDBus::sessionBus().registerObject("<object-path>", this,   + QDBusConnection::sessionBus().registerObject("<object-path>", this,  
−                                    QDBusConnection::ExportSlots); +                                              QDBusConnection::ExportScriptableSlots);
  </code>   </code>
    
− Normally, "<object-path>" will be the argument the class was passing to the {{class|DCOPObject}} constructor. Don't forget the leading slash. Another useful option to the third argument is QDBusConnection::ExportProperties, which will export the scriptable properties. + Normally, "<object-path>" will be the argument the class was passing to the {{class|DCOPObject}} constructor. Don't forget the leading slash. Another useful option to the third argument is QDBusConnection::ExportScriptableProperties, which will export the scriptable properties.
    
  ===Signals===   ===Signals===
  DCOP had broken support for signals. They were public methods, while normal signals in {{qt|QObject}} are protected methods. The correct way to port from DCOP signals is to refactor the code to support signals correctly.   DCOP had broken support for signals. They were public methods, while normal signals in {{qt|QObject}} are protected methods. The correct way to port from DCOP signals is to refactor the code to support signals correctly.
−  
− On the current version of QtDBus, you cannot use QDBusConnection::ExportSignals. This is a known limitation and will be fixed in the future. In order to use signals, you'll need to write an adaptor.  
    
  Adaptors are a special {{qt|QObject}} that you attach to your normal {{qt|QObject}} and whose sole purpose is to relay things to and from the bus. You'll generally use it to export more than one interface or when you need to translate the call arguments in any way.   Adaptors are a special {{qt|QObject}} that you attach to your normal {{qt|QObject}} and whose sole purpose is to relay things to and from the bus. You'll generally use it to export more than one interface or when you need to translate the call arguments in any way.
Line 124:
Line 121:
  <code cpp>   <code cpp>
  new MyAdaptor(this);   new MyAdaptor(this);
− QDBus::sessionBus().registerObject("/<object-path>", this, + QDBusConnection::sessionBus().registerObject("/<object-path>", this,
−                                    QDBusConnection::ExportAdaptors); +                                              QDBusConnection::ExportAdaptors);
  </code>   </code>
    
Line 172:
Line 169:
  {   {
       QDBusMessage reply;        QDBusMessage reply;
  +     QDBusConnection connection;
    
  public Q_SLOTS:   public Q_SLOTS:
Line 177:
Line 175:
                                     const QDBusMessage &msg)                                      const QDBusMessage &msg)
       {        {
−          reply = QDBusMessage::methodReply(msg); +         connection = QDBusConnection::sender();
  +          reply = QDBusMessage::createReply(msg);
           QTimer::singleShot(0, this, SLOT(processLater());            QTimer::singleShot(0, this, SLOT(processLater());
           return QString();       // reply will be ignored            return QString();       // reply will be ignored
Line 185:
Line 184:
       {        {
           reply << QString(QLatin1String("foo"));            reply << QString(QLatin1String("foo"));
−          reply.connection().send(reply); +          connection.send(reply);
       }        }
  };   };

@@ Line 27: / Line 27: @@
      reply.get(icon);
 return icon;
-</code>
+</syntaxhighlight>
@@ Line 36: / Line 36: @@
 QDBusReply<QString> reply = kded.call("iconForURL", url.url());
 return reply;
-</code>
+</syntaxhighlight>
 Things to note in the code:
@@ Line 58: / Line 58: @@
          /* etc. */
+}
-</code>
+</syntaxhighlight>
 ===Converting from DCOPObject===
@@ Line 70: / Line 70: @@
 public Q_SLOTS:
      Q_SCRIPTABLE void methodName();
-</code>
+</syntaxhighlight>
 * Change "ASYNC" to "Q_NOREPLY void"
 * Remove the call to the DCOPObject constructor in the class' constructor.
@@ Line 81: / Line 81: @@
 QDBusConnection::sessionBus().registerObject("<object-path>", this,
                              QDBusConnection::ExportScriptableSlots);
-</code>
+</syntaxhighlight>
 Normally, "<object-path>" will be the argument the class was passing to the {{class|DCOPObject}} constructor. Don't forget the leading slash. Another useful option to the third argument is QDBusConnection::ExportScriptableProperties, which will export the scriptable properties.
@@ Line 103: / Line 103: @@
      void signal2(const QString &argument);
 };
-</code>
+</syntaxhighlight>
 And the implementation will look like:
@@ Line 116: / Line 116: @@
      */
+}
-</code>
+</syntaxhighlight>
 In the class using the adaptor, do this:
@@ Line 123: / Line 123: @@
 QDBusConnection::sessionBus().registerObject("/<object-path>", this,
                                               QDBusConnection::ExportAdaptors);
-</code>
+</syntaxhighlight>
 Things to notice:
@@ Line 162: / Line 162: @@
+     }
 };
-</code>
+</syntaxhighlight>
 The equivalent code with QtDBus would be:
@@ Line 189: / Line 189: @@
+     }
 };
-</code>
+</syntaxhighlight>
 ==Caveats when porting==

Development/Tutorials/Porting to D-Bus - Revision history

Neverendingo: Text replace - "" to ""

Neverendingo: Text replace - "" to ""

Neverendingo: Text replace - "" to ""

Tampakrap at 19:27, 11 July 2009

Thiago: Performance improvement: QString(QLatin1String(...)) is stupid

Thiago: /* DCOP Transactions */

Thiago: Update to QDBusContext

Winterz: descroll

Pino: use the right classes for code highlighting

Thiago: Update to the API found in the released Qt 4.2

Neverendingo: Text replace - "`" to ""`

`Neverendingo: Text replace - "`" to ""

Neverendingo: Text replace - "`" to ""`