File BRANCH_UPDATE.diff of Package libdbus-1-qt3-0

Overview Repositories Revisions Requests Users Attributes Meta

File BRANCH_UPDATE.diff of Package libdbus-1-qt3-0 (Revision add045c8abcff69a718da132a71e02ce)

Currently displaying revision add045c8abcff69a718da132a71e02ce , Show latest

--- test/cross-test/crosstest-client.pro
+++ test/cross-test/crosstest-client.pro
@@ -3,11 +3,11 @@ TEMPLATE = app
 CONFIG += qt thread
 
 SOURCES += crosstest-client.cpp \
-           singletestsproxy.cpp testclient.cpp \
+           singletestsproxy.cpp testclientinterface.cpp \
            testsproxy.cpp testsignalsproxy.cpp
 
 HEADERS += crosstest-client.h \
-           singletestsproxy.h testclient.h \
+           singletestsproxy.h testclientinterface.h \
            testsproxy.h testsignalsproxy.h
 
 TARGET = crosstest-client
--- test/cross-test/crosstest-client.h
+++ test/cross-test/crosstest-client.h
@@ -10,7 +10,7 @@
 #include <dbus/qdbusconnection.h>
 
 // local includes
-#include "testclient.h"
+#include "testclientinterface.h"
 
 // forward declarations
 class QDBusMessage;
--- test/cross-test/interfaceimpls.h
+++ test/cross-test/interfaceimpls.h
@@ -5,9 +5,9 @@
 #include <qobject.h>
 
 // local includes
-#include "singletests.h"
-#include "tests.h"
-#include "testsignals.h"
+#include "singletestsinterface.h"
+#include "testsinterface.h"
+#include "testsignalsinterface.h"
 
 // forward declarations
 class TestNode;
--- test/cross-test/crosstest-server.pro
+++ test/cross-test/crosstest-server.pro
@@ -3,10 +3,12 @@ TEMPLATE = app
 CONFIG += qt thread
 
 SOURCES += crosstest-server.cpp interfaceimpls.cpp \
-           singletests.cpp testclientproxy.cpp tests.cpp testsignals.cpp
+           singletestsinterface.cpp testclientproxy.cpp \
+           testsinterface.cpp testsignalsinterface.cpp
 
 HEADERS += crosstest-server.h interfaceimpls.h \
-           singletests.h testclientproxy.h tests.h testsignals.h
+           singletestsinterface.h testclientproxy.h \
+           testsinterface.h testsignalsinterface.h
 
 TARGET = crosstest-server
 
--- test/cross-test/Makefile
+++ test/cross-test/Makefile
@@ -1,7 +1,10 @@
-GENERATED = tests.h tests.cpp testsproxy.h testsproxy.cpp \
-            singletests.h singletests.cpp singletestsproxy.h singletestsproxy.cpp \
-            testclient.h testclient.cpp testclientproxy.h testclientproxy.cpp \
-            testsignals.h testsignals.cpp testsignalsproxy.h testsignalsproxy.cpp
+GENERATED = testsinterface.h testsinterface.cpp testsproxy.h testsproxy.cpp \
+            singletestsinterface.h singletestsinterface.cpp \
+            singletestsproxy.h singletestsproxy.cpp \
+            testclientinterface.h testclientinterface.cpp \
+            testclientproxy.h testclientproxy.cpp \
+            testsignalsinterface.h testsignalsinterface.cpp \
+            testsignalsproxy.h testsignalsproxy.cpp
 
 all: cross-test-compile
 
--- qdbusmarshall.cpp
+++ qdbusmarshall.cpp
@@ -456,9 +456,10 @@ static QDBusData qFetchParameter(DBusMes
     case DBUS_TYPE_DOUBLE:
         return QDBusData::fromDouble(qIterGet<double>(it));
     case DBUS_TYPE_STRING:
-    case DBUS_TYPE_OBJECT_PATH:
     case DBUS_TYPE_SIGNATURE:
         return QDBusData::fromString(QString::fromUtf8(qIterGet<char *>(it)));
+    case DBUS_TYPE_OBJECT_PATH:
+        return QDBusData::fromObjectPath(QDBusObjectPath(qIterGet<char *>(it)));
     case DBUS_TYPE_ARRAY: {
         int arrayType = dbus_message_iter_get_element_type(it);
 
--- tools/dbusxml2qt3/classgen.cpp
+++ tools/dbusxml2qt3/classgen.cpp
@@ -192,6 +192,8 @@ static void writeHeaderIncludes(const Cl
             includes["qdbus"].insertString("<dbus/qdbusobject.h>");
             forwards.insertString("class QDBusError");
             forwards.insertString("class QDomElement");
+            if (!classData.signals.isEmpty())
+                forwards.insertString("class QString");
             break;
 
         case Class::Proxy:
@@ -266,6 +268,15 @@ static void writeSourceIncludes(const Cl
         extractSourceIncludes(*it, includes);
     }
 
+    it    = classData.signals.begin();
+    endIt = classData.signals.end();
+    for (; it != endIt; ++it)
+    {
+        if ((*it).arguments.isEmpty()) continue;
+
+        extractSourceIncludes(*it, includes);
+    }
+
     QValueList<Property>::const_iterator propertyIt = classData.properties.begin();
     QValueList<Property>::const_iterator propertyEndIt = classData.properties.end();
     for (; propertyIt != propertyEndIt; ++propertyIt)
@@ -318,24 +329,6 @@ static void writeSourceIncludes(const Cl
 
     if (!includes["local"].isEmpty())
         writeIncludes("local", includes["local"].keys(), stream);
-    else
-        stream << "// local includes" << endl;
-
-    switch (role)
-    {
-        case Class::Interface:
-            stream << "#include \"" << classData.name.lower() << ".h\"" << endl;
-            break;
-
-        case Class::Proxy:
-            stream << "#include \"" << classData.name.lower() << "proxy.h\""
-                   << endl;
-            break;
-
-        case Class::Node:
-            stream << "#include \"" << classData.name.lower() << ".h\"" << endl;
-            break;
-    }
 
     stream << endl;
 }
@@ -491,6 +484,7 @@ static void writeMethodDeclarations(cons
 
             case Class::Proxy:
                 pureVirtual = false;
+                stream << "public:" << endl;
                 stream << "    virtual void setDBusProperty(const QString& name,"
                        << " const QDBusVariant& variant, QDBusError& error);"
                        << endl;
@@ -649,6 +643,57 @@ static void writeProxyProperties(const C
     }
 }
 
+bool ClassGenerator::initStreams(const QString& baseName,
+                                 QTextStream& headerStream,
+                                 QTextStream& sourceStream)
+{
+    QFile* headerFile = new QFile(baseName + ".h");
+    QFile* sourceFile = new QFile(baseName + ".cpp");
+
+    if (!headerFile->open(IO_WriteOnly) || !sourceFile->open(IO_WriteOnly))
+    {
+        delete headerFile;
+        delete sourceFile;
+
+        return false;
+    }
+
+    headerStream.setDevice(headerFile);
+    sourceStream.setDevice(sourceFile);
+
+    // create header
+    writeFileHeader(headerStream);
+    openIncludeGuard(baseName, headerStream);
+
+    // create source
+    writeFileHeader(sourceStream);
+    sourceStream << "// declaration include" << endl;
+    sourceStream << "#include \"" << baseName << ".h\"" << endl;
+    sourceStream << endl;
+
+    return true;
+}
+
+bool ClassGenerator::finishStreams(const QString& baseName,
+                                   QTextStream& headerStream,
+                                   QTextStream& sourceStream)
+{
+    closeIncludeGuard(baseName, headerStream);
+    writeFileFooter(headerStream);
+
+    writeFileFooter(sourceStream);
+
+    QIODevice* device = headerStream.device();
+    headerStream.unsetDevice();
+    delete device;
+
+    device = sourceStream.device();
+    sourceStream.unsetDevice();
+    delete device;
+
+    return true;
+}
+
 bool ClassGenerator::extractClass(const QDomElement& interfaceElement,
                                    Class& classData)
 {
@@ -668,22 +713,11 @@ bool ClassGenerator::extractClass(const 
     return MethodGenerator::extractMethods(interfaceElement, classData);
 }
 
-bool ClassGenerator::generateInterface(const Class& classData)
+bool ClassGenerator::generateInterface(const Class& classData,
+                                       QTextStream& headerStream,
+                                       QTextStream& sourceStream)
 {
-    QFile headerFile(classData.name.lower() + ".h");
-    QFile sourceFile(classData.name.lower() + ".cpp");
-
-    if (!headerFile.open(IO_WriteOnly) || !sourceFile.open(IO_WriteOnly))
-        return false;
-
-    // init streams
-    QTextStream headerStream(&headerFile);
-    QTextStream sourceStream(&sourceFile);
-
     // create header
-    writeFileHeader(headerStream);
-    openIncludeGuard(classData.name, headerStream);
-
     writeHeaderIncludes(classData, Class::Interface, headerStream);
 
     openNamespaces(classData.namespaces, headerStream);
@@ -695,11 +729,8 @@ bool ClassGenerator::generateInterface(c
 
     closeClassDeclaration(classData, Class::Interface, headerStream);
     closeNamespaces(classData.namespaces, headerStream);
-    closeIncludeGuard(classData.name, headerStream);
-    writeFileFooter(headerStream);
 
     // create source
-    writeFileHeader(sourceStream);
     writeSourceIncludes(classData, Class::Interface, sourceStream);
 
     openNamespaces(classData.namespaces, sourceStream);
@@ -713,27 +744,15 @@ bool ClassGenerator::generateInterface(c
     MethodGenerator::writeInterfaceMainMethod(classData, sourceStream);
 
     closeNamespaces(classData.namespaces, sourceStream);
-    writeFileFooter(sourceStream);
 
     return true;
 }
 
-bool ClassGenerator::generateProxy(const Class& classData)
+bool ClassGenerator::generateProxy(const Class& classData,
+                                   QTextStream& headerStream,
+                                   QTextStream& sourceStream)
 {
-    QFile headerFile(classData.name.lower() + "proxy.h");
-    QFile sourceFile(classData.name.lower() + "proxy.cpp");
-
-    if (!headerFile.open(IO_WriteOnly) || !sourceFile.open(IO_WriteOnly))
-        return false;
-
-    // init streams
-    QTextStream headerStream(&headerFile);
-    QTextStream sourceStream(&sourceFile);
-
     // create header
-    writeFileHeader(headerStream);
-    openIncludeGuard(classData.name + "PROXY", headerStream);
-
     writeHeaderIncludes(classData, Class::Proxy, headerStream);
 
     openNamespaces(classData.namespaces, headerStream);
@@ -744,11 +763,8 @@ bool ClassGenerator::generateProxy(const
 
     closeClassDeclaration(classData, Class::Proxy, headerStream);
     closeNamespaces(classData.namespaces, headerStream);
-    closeIncludeGuard(classData.name, headerStream);
-    writeFileFooter(headerStream);
 
     // create source
-    writeFileHeader(sourceStream);
     writeSourceIncludes(classData, Class::Proxy, sourceStream);
 
     openNamespaces(classData.namespaces, sourceStream);
@@ -763,28 +779,16 @@ bool ClassGenerator::generateProxy(const
         MethodGenerator::writeSignalHandler(classData, sourceStream);
 
     closeNamespaces(classData.namespaces, sourceStream);
-    writeFileFooter(sourceStream);
 
     return true;
 }
 
 bool ClassGenerator::generateNode(const Class& classData,
-                                  const QValueList<Class>& interfaces)
+                                  const QValueList<Class>& interfaces,
+                                  QTextStream& headerStream,
+                                  QTextStream& sourceStream)
 {
-    QFile headerFile(classData.name.lower() + ".h");
-    QFile sourceFile(classData.name.lower() + ".cpp");
-
-    if (!headerFile.open(IO_WriteOnly) || !sourceFile.open(IO_WriteOnly))
-        return false;
-
-    // init streams
-    QTextStream headerStream(&headerFile);
-    QTextStream sourceStream(&sourceFile);
-
     // create header
-    writeFileHeader(headerStream);
-    openIncludeGuard(classData.name, headerStream);
-
     writeHeaderIncludes(classData, Class::Node, headerStream);
 
     openNamespaces(classData.namespaces, headerStream);
@@ -793,10 +797,8 @@ bool ClassGenerator::generateNode(const 
     closeClassDeclaration(classData, Class::Node, headerStream);
     closeNamespaces(classData.namespaces, headerStream);
     closeIncludeGuard(classData.name, headerStream);
-    writeFileFooter(headerStream);
 
     // create source
-    writeFileHeader(sourceStream);
     writeSourceIncludes(classData, Class::Node, sourceStream);
     writeInterfaceIncludes(interfaces, sourceStream);
 
@@ -809,7 +811,6 @@ bool ClassGenerator::generateNode(const 
     MethodGenerator::writeNodeMethods(classData, interfaces, sourceStream);
 
     closeNamespaces(classData.namespaces, sourceStream);
-    writeFileFooter(sourceStream);
 
     return true;
 }
--- tools/dbusxml2qt3/classgen.h
+++ tools/dbusxml2qt3/classgen.h
@@ -26,16 +26,27 @@
 // forward declarations
 class Class;
 class QDomElement;
+class QTextStream;
 template<typename T> class QValueList;
 
 class ClassGenerator
 {
 public:
+    static bool initStreams(const QString& baseName,
+                            QTextStream& headerStream, QTextStream& sourceStream);
+
+    static bool finishStreams(const QString& baseName,
+                              QTextStream& headerStream, QTextStream& sourceStream);
+
     static bool extractClass(const QDomElement& interfaceElement, Class& classData);
-    static bool generateInterface(const Class& classData);
-    static bool generateProxy(const Class& classData);
+    static bool generateInterface(const Class& classData,
+                                  QTextStream& headerStream,
+                                  QTextStream& sourceStream);
+    static bool generateProxy(const Class& classData,
+                              QTextStream& headerStream, QTextStream& sourceStream);
     static bool generateNode(const Class& classData,
-                             const QValueList<Class>& interfaces);
+                             const QValueList<Class>& interfaces,
+                             QTextStream& headerStream, QTextStream& sourceStream);
 };
 
 #endif
--- tools/dbusxml2qt3/main.cpp
+++ tools/dbusxml2qt3/main.cpp
@@ -20,38 +20,58 @@
 *   OTHER DEALINGS IN THE SOFTWARE.
 */
 
+// standard includes
+#include <iostream>
+#include <cstdlib>
+
 // Qt includes
 #include <qdom.h>
 #include <qfile.h>
+#include <qmap.h>
+#include <qtextstream.h>
 
 // local includes
 #include "classgen.h"
 #include "methodgen.h"
 
+typedef QMap<QString, QString> OptionMap;
+
+void usage();
+
+OptionMap parseOptions(int argc, char** argv);
+
+bool checkForOption(const OptionMap& options, const QString& option)
+{
+    return options.find(option) != options.end();
+}
+
 int main(int argc, char** argv)
 {
-    if (argc < 2)
-    {
-        qFatal("Missing input file: dbusxml2qt3 <introspection-file>"
-               " [NodeClassName]");
-    }
-    else if (argc > 3)
+    const OptionMap options = parseOptions(argc, argv);
+
+    if (!checkForOption(options, "filename"))
     {
-        qFatal("Too many arguments: dbusxml2qt3 <introspection-file>"
-               " [NodeClassName]");
+        std::cerr << "dbusxml2qt3: introspection data file missing" << std::endl;
+        usage();
+        exit(1);
     }
 
-    QString fileName = QString::fromLocal8Bit(argv[1]);
-
+    QString fileName = options["filename"];
     QFile file(fileName);
     if (!file.exists())
     {
-        qFatal("File '%s' does not exist", argv[1]);
+        std::cerr << "dbusxml2qt3: introspection data file '"
+                  << fileName.local8Bit().data()
+                  << "' does not exist" << std::endl;
+        exit(2);
     }
 
     if (!file.open(IO_ReadOnly))
     {
-        qFatal("File '%s' can not be read", argv[1]);
+        std::cerr << "dbusxml2qt3: introspection data file '"
+                  << fileName.local8Bit().data()
+                  << "' cannot be read" << std::endl;
+        exit(2);
     }
 
     QDomDocument document;
@@ -60,7 +80,10 @@ int main(int argc, char** argv)
     {
         file.close();
 
-        qFatal("Content of file '%s' not parsable", argv[1]);
+        std::cerr << "dbusxml2qt3: introspection data file '"
+                  << fileName.local8Bit().data()
+                  << "' cannot be parsed" << std::endl;
+        exit(2);
     }
 
     file.close();
@@ -68,12 +91,13 @@ int main(int argc, char** argv)
     QDomElement rootElement = document.documentElement();
     if (rootElement.isNull() || rootElement.tagName() != "node")
     {
-        qFatal("File '%s' is not a D-Bus introspection data file", argv[1]);
+        std::cerr << "dbusxml2qt3: introspection data file '"
+                  << fileName.local8Bit().data()
+                  << "' does not have a 'node' element as its root node"
+                  << std::endl;
+        exit(2);
     }
 
-    QString nodeClassName;
-    if (argc == 3) nodeClassName = QString::fromLocal8Bit(argv[2]);
-
     QValueList<Class> interfaces;
     bool hasIntrospectable = false;
 
@@ -91,9 +115,6 @@ int main(int argc, char** argv)
                 Class classData;
                 if (ClassGenerator::extractClass(element, classData))
                 {
-                    ClassGenerator::generateInterface(classData);
-                    ClassGenerator::generateProxy(classData);
-
                     if (classData.dbusName == "org.freedesktop.DBus.Introspectable")
                         hasIntrospectable = true;
                     else
@@ -103,7 +124,152 @@ int main(int argc, char** argv)
         }
     }
 
-    if (!nodeClassName.isEmpty() && !interfaces.isEmpty())
+    if (interfaces.isEmpty())
+    {
+        std::cerr << "dbusxml2qt3: introspection data file '"
+                  << fileName.local8Bit().data()
+                  << "' does not contain any valid interface descriptions"
+                  << std::endl;
+        exit(3);
+    }
+
+    bool generateProxies    = checkForOption(options, "proxy");
+    bool generateInterfaces = checkForOption(options, "interface");
+    bool generateNode       = checkForOption(options, "node");
+
+    // if no specific option is selected, we generate everything
+    bool generateAll = !(generateProxies || generateInterfaces || generateNode);
+
+    if (checkForOption(options, "classname"))
+    {
+        // class name only useful for single interfaces or just node
+        if (interfaces.count() > 1 && (generateAll || generateInterfaces || generateProxies))
+        {
+            std::cerr << "dbusxml2qt3: class name option specified but "
+                      << "introspection data file '"
+                      << fileName.local8Bit().data()
+                      << "' contains more than one interface description"
+                      << std::endl;
+            exit(3);
+        }
+
+        QStringList nameParts = QStringList::split("::", options["classname"]);
+
+        interfaces[0].name = nameParts.back();
+
+        nameParts.pop_back();
+        interfaces[0].namespaces = nameParts;
+    }
+
+    if (checkForOption(options, "namespace"))
+    {
+        QStringList nameParts = QStringList::split("::", options["namespace"]);
+
+        QValueList<Class>::iterator it    = interfaces.begin();
+        QValueList<Class>::iterator endIt = interfaces.end();
+        for (; it != endIt; ++it)
+        {
+            (*it).namespaces = nameParts;
+        }
+    }
+
+    if (generateInterfaces || generateAll)
+    {
+        QTextStream headerStream;
+        QTextStream sourceStream;
+
+        QString baseName = options["interface"];
+        if (!baseName.isEmpty())
+        {
+            if (!ClassGenerator::initStreams(baseName, headerStream, sourceStream))
+            {
+                std::cerr << "dbusxml2qt3: proxy files, using base name '"
+                          << baseName.local8Bit().data()
+                          << "', could not be opened for writing"
+                          << std::endl;
+                exit(4);
+            }
+        }
+
+        QValueList<Class>::const_iterator it    = interfaces.begin();
+        QValueList<Class>::const_iterator endIt = interfaces.end();
+        for (; it != endIt; ++it)
+        {
+            if (baseName.isEmpty())
+            {
+                if (!ClassGenerator::initStreams((*it).name.lower() + "interface",
+                                                 headerStream, sourceStream))
+                {
+                    std::cerr << "dbusxml2qt3: interface files, using base name '"
+                            << baseName.local8Bit().data()
+                            << "', could not be opened for writing"
+                            << std::endl;
+                    exit(4);
+                }
+            }
+
+            ClassGenerator::generateInterface(*it, headerStream, sourceStream);
+
+            if (baseName.isEmpty())
+            {
+                ClassGenerator::finishStreams((*it).name.lower() + "interface",
+                                              headerStream, sourceStream);
+            }
+        }
+
+        if (!baseName.isEmpty())
+            ClassGenerator::finishStreams(baseName, headerStream, sourceStream);
+    }
+
+    if (generateProxies || generateAll)
+    {
+        QTextStream headerStream;
+        QTextStream sourceStream;
+
+        QString baseName = options["proxy"];
+        if (!baseName.isEmpty())
+        {
+            if (!ClassGenerator::initStreams(baseName, headerStream, sourceStream))
+            {
+                std::cerr << "dbusxml2qt3: proxy files, using base name '"
+                          << baseName.local8Bit().data()
+                          << "', could not be opened for writing"
+                          << std::endl;
+                exit(4);
+            }
+        }
+
+        QValueList<Class>::const_iterator it    = interfaces.begin();
+        QValueList<Class>::const_iterator endIt = interfaces.end();
+        for (; it != endIt; ++it)
+        {
+            if (baseName.isEmpty())
+            {
+                if (!ClassGenerator::initStreams((*it).name.lower() + "proxy",
+                                                 headerStream, sourceStream))
+                {
+                    std::cerr << "dbusxml2qt3: proxy files, using base name '"
+                            << baseName.local8Bit().data()
+                            << "', could not be opened for writing"
+                            << std::endl;
+                    exit(4);
+                }
+            }
+
+            ClassGenerator::generateProxy(*it, headerStream, sourceStream);
+
+            if (baseName.isEmpty())
+            {
+                ClassGenerator::finishStreams((*it).name.lower() + "proxy",
+                                              headerStream, sourceStream);
+            }
+        }
+
+        if (!baseName.isEmpty())
+            ClassGenerator::finishStreams(baseName, headerStream, sourceStream);
+    }
+
+    if (generateNode || generateAll)
     {
         if (!hasIntrospectable)
         {
@@ -133,10 +299,40 @@ int main(int argc, char** argv)
             method.arguments << argument;
             classData.methods << method;
 
-            ClassGenerator::generateInterface(classData);
+            QTextStream headerStream;
+            QTextStream sourceStream;
+
+            if (!ClassGenerator::initStreams(classData.name.lower() + "interface",
+                                             headerStream, sourceStream))
+            {
+                std::cerr << "dbusxml2qt3: interface files, using base name '"
+                        << classData.name.lower().local8Bit().data() << "interface"
+                        << "', could not be opened for writing"
+                        << std::endl;
+                exit(4);
+            }
+
+            ClassGenerator::generateInterface(classData,
+                                              headerStream, sourceStream);
+
+            ClassGenerator::finishStreams(classData.name.lower() + "interface",
+                                          headerStream, sourceStream);
         }
 
-        qDebug("Generating node %s", nodeClassName.local8Bit().data());
+        QString nodeClassName = options["classname"];
+        if (nodeClassName.isEmpty())
+        {
+            nodeClassName = rootElement.attribute("name");
+            if (nodeClassName.startsWith("/")) nodeClassName = nodeClassName.mid(1);
+            if (nodeClassName.isEmpty())
+            {
+                std::cerr << "dbusxml2qt3: cannot generate node without class name."
+                          << std::endl;
+                exit(3);
+            }
+
+            nodeClassName.replace('/', "_");
+        }
 
         QStringList nameParts = QStringList::split("::", nodeClassName);
 
@@ -146,10 +342,291 @@ int main(int argc, char** argv)
         nameParts.pop_back();
         classData.namespaces = nameParts;
 
-        ClassGenerator::generateNode(classData, interfaces);
+        if (checkForOption(options, "namespace"))
+        {
+            nameParts = QStringList::split("::", options["namespace"]);
+
+            classData.namespaces = nameParts;
+        }
+
+        QTextStream headerStream;
+        QTextStream sourceStream;
+
+        QString baseName = options["node"];
+        if (baseName.isEmpty()) baseName = classData.name.lower() + "node";
+
+        if (!ClassGenerator::initStreams(baseName, headerStream, sourceStream))
+        {
+            std::cerr << "dbusxml2qt3: interface files, using base name '"
+                      << baseName.local8Bit().data()
+                      << "', could not be opened for writing"
+                      << std::endl;
+            exit(4);
+        }
+
+        ClassGenerator::generateNode(classData, interfaces,
+                                     headerStream, sourceStream);
+
+        ClassGenerator::finishStreams(baseName, headerStream, sourceStream);
     }
 
     return 0;
 }
 
+void usage()
+{
+    std::cout << "usage: dbusxml2qt3 [options] <introspectionfile>" << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "Options:" << std::endl;
+    std::cout << "-h, --help" << std::endl;
+    std::cout << "\tDisplay this help" << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "-c <classname>, --class <classname>" << std::endl;
+    std::cout << "\tUse 'classname' instead of last string in interface name"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "-N [namespace], --namespace [namespace]" << std::endl;
+    std::cout << "\tOverride namespaces. If provided, use 'namespace' instead, otherwise ignore namespaces"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "-i [basename], --interface [basename]" << std::endl;
+    std::cout << "\tGenerate interface files. If provided, use 'basename' for filenames"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "-p [basename], --proxy [basename]" << std::endl;
+    std::cout << "\tGenerate proxy files. If provided, use 'basename' for filenames"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "-n [basename], --node [basename]" << std::endl;
+    std::cout << "\tGenerate node files. If provided, use 'basename' for filenames"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "Examples:" << std::endl;
+    std::cout << "dbusxml2qt3 myinterface.xml" << std::endl;
+    std::cout << "\tGenerates as much as possible, i.e. interfaces, proxies and, "
+              << "if a node name is specified in 'myinterface.xml', the node files"
+              << std::endl;
+    std::cout << "\tUses lowercased interface names as plus type specific suffix "
+              << "for the file names" << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "dbusxml2qt3 myinterface.xml -N" << std::endl;
+    std::cout << "\tSame as first example but does not use namespaces"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "dbusxml2qt3 myinterface.xml -N org::myorg" << std::endl;
+    std::cout << "\tSame as first example but overrides namespaces with 'org::myorg'"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "dbusxml2qt3 myinterface.xml -n mynode -c MyNode" << std::endl;
+    std::cout << "\tGenerate only node files, use 'mynode' as the file basename "
+              << "and classname 'MyClass'"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "dbusxml2qt3 myinterface.xml -p" << std::endl;
+    std::cout << "\tGenerate only proxy files, use default file basename"
+              << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "dbusxml2qt3 myinterface.xml -p myproxy" << std::endl;
+    std::cout << "\tGenerate only proxy files, use 'myproxy' as the file basename"
+              << std::endl;
+    std::cout << std::endl;
+}
+
+bool testAndSetOption(OptionMap& options, const QString& option, const QString& value)
+{
+    OptionMap::iterator it = options.find(option);
+    if (it == options.end())
+    {
+        options.insert(option, value);
+        return true;
+    }
+
+    return false;
+}
+
+OptionMap parseOptions(int argc, char** argv)
+{
+    QStringList args;
+    for (int i = 1; i < argc; ++i)
+    {
+        args << QString::fromLocal8Bit(argv[i]);
+    }
+
+    OptionMap options;
+
+    while (!args.isEmpty())
+    {
+        QString arg = args.front();
+        args.pop_front();
+
+        if (arg.startsWith("-"))
+        {
+            if (arg.endsWith("help"))
+            {
+                usage();
+                exit(0);
+            }
+            else if (arg == "-p" || arg == "--proxy")
+            {
+                // test for optional argument
+                QString value;
+                if (!args.isEmpty() > 0 && !args[0].startsWith("-"))
+                {
+                    value = args.front();
+                    args.pop_front();
+                }
+
+                if (!testAndSetOption(options, "proxy", value))
+                {
+                    std::cerr << "Error while parsing command line argument '"
+                              << arg.local8Bit().data() << "'";
+
+                    if (!value.isEmpty())
+                        std::cerr << ", value '" << value.local8Bit().data() << "':";
+                    else
+                        std::cerr << ":";
+
+                    std::cerr << " already set to '"
+                              << options["proxy"].local8Bit().data() << std::endl;
+                }
+            }
+            else if (arg == "-i" || arg == "--interface")
+            {
+                // test for optional argument
+                QString value;
+                if (!args.isEmpty() > 0 && !args[0].startsWith("-"))
+                {
+                    value = args.front();
+                    args.pop_front();
+                }
+
+                if (!testAndSetOption(options, "interface", value))
+                {
+                    std::cerr << "Error while parsing command line argument '"
+                              << arg.local8Bit().data() << "'";
+
+                    if (!value.isEmpty())
+                        std::cerr << ", value '" << value.local8Bit().data() << "':";
+                    else
+                        std::cerr << ":";
+
+                    std::cerr << " already set to '"
+                              << options["interface"].local8Bit().data() << std::endl;
+                }
+            }
+            else if (arg == "-n" || arg == "--node")
+            {
+                // test for optional argument
+                QString value;
+                if (!args.isEmpty() > 0 && !args[0].startsWith("-"))
+                {
+                    value = args.front();
+                    args.pop_front();
+                }
+
+                if (!testAndSetOption(options, "node", value))
+                {
+                    std::cerr << "Error while parsing command line argument '"
+                              << arg.local8Bit().data() << "'";
+
+                    if (!value.isEmpty())
+                        std::cerr << ", value '" << value.local8Bit().data() << "':";
+                    else
+                        std::cerr << ":";
+
+                    std::cerr << " already set to '"
+                              << options["node"].local8Bit().data() << std::endl;
+                }
+            }
+            else if (arg == "-N" || arg == "--namespace")
+            {
+                // test for optional argument
+                QString value;
+                if (!args.isEmpty() > 0 && !args[0].startsWith("-"))
+                {
+                    value = args.front();
+                    args.pop_front();
+                }
+
+                if (!testAndSetOption(options, "namespace", value))
+                {
+                    std::cerr << "Error while parsing command line argument '"
+                              << arg.local8Bit().data() << "'";
+
+                    if (!value.isEmpty())
+                        std::cerr << ", value '" << value.local8Bit().data() << "':";
+                    else
+                        std::cerr << ":";
+
+                    std::cerr << " already set to '"
+                              << options["namespace"].local8Bit().data() << std::endl;
+                }
+            }
+            else if (arg == "-c" || arg == "--class")
+            {
+                // test for mandatory argument
+                if (args.isEmpty() || args[0].startsWith("-"))
+                {
+                    std::cerr << "Error while parsing command line argument '"
+                              << arg.local8Bit().data()
+                              << "': mandatory parameter missing" << std::endl;
+                    usage();
+                    exit(1);
+                }
+
+                QString value = args.front();
+                args.pop_front();
+
+                if (!testAndSetOption(options, "classname", value))
+                {
+                    std::cerr << "Error while parsing command line argument '"
+                              << arg.local8Bit().data() << "'";
+
+                    if (!value.isEmpty())
+                        std::cerr << ", value '" << value.local8Bit().data() << "':";
+                    else
+                        std::cerr << ":";
+
+                    std::cerr << " already set to '"
+                              << options["classname"].local8Bit().data() << std::endl;
+                }
+            }
+            else
+            {
+                std::cerr << "Error while parsing command line argument '"
+                          << arg.local8Bit().data()
+                          << "': unknown option" << std::endl;
+                usage();
+                exit(1);
+            }
+        }
+        else
+        {
+            if (!testAndSetOption(options, "filename", arg))
+            {
+                std::cerr << "Error while parsing command line argument '"
+                          << arg.local8Bit().data()
+                          << "': introspection file already given as '"
+                          << options["filename"].local8Bit().data() << std::endl;
+                usage();
+                exit(1);
+            }
+        }
+    }
+
+    return options;
+}
+
 // End of File
--- tools/dbusxml2qt3/methodgen.cpp
+++ tools/dbusxml2qt3/methodgen.cpp
@@ -156,6 +156,7 @@ static bool parseDBusSignature(const QSt
                     argument.forwardDeclarations += key.forwardDeclarations;
 
                     argument.sourceIncludes = key.sourceIncludes;
+                    argument.sourceIncludes["qdbus"].append("<dbus/qdbusdata.h>");
                     argument.sourceIncludes["qdbus"].append("<dbus/qdbusdatamap.h>");
                 }
                 else
@@ -173,6 +174,7 @@ static bool parseDBusSignature(const QSt
 
                     argument.sourceIncludes = key.sourceIncludes;
                     argument.sourceIncludes["Qt"].append("<qmap.h>");
+                    argument.sourceIncludes["qdbus"].append("<dbus/qdbusdata.h>");
                     argument.sourceIncludes["qdbus"].append("<dbus/qdbusdatamap.h>");
 
                     QMap<QString, QStringList>::const_iterator it =
@@ -196,6 +198,7 @@ static bool parseDBusSignature(const QSt
                 argument.forwardDeclarations += key.forwardDeclarations;
 
                 argument.sourceIncludes = key.sourceIncludes;
+                argument.sourceIncludes["qdbus"].append("<dbus/qdbusdata.h>");
                 argument.sourceIncludes["qdbus"].append("<dbus/qdbusdatamap.h>");
             }
         }
--- Makefile.am
+++ Makefile.am
@@ -23,24 +23,24 @@ dbusinclude_HEADERS=	\
 #	dbus/qdbusserver.h
 
 libdbus_1_qt3_la_SOURCES =                   \
-	$(srcdir)/dbus/qdbusproxy.h      \
-	$(srcdir)/dbus/qdbusserver.h     \
-	$(srcdir)/qdbusconnection_p.h    \
-	$(srcdir)/qdbusconnection.cpp    \
-	$(srcdir)/qdbuserror.cpp         \
-	$(srcdir)/qdbusintegrator.cpp    \
-	$(srcdir)/qdbusmarshall.cpp      \
-	$(srcdir)/qdbusmessage.cpp       \
-	$(srcdir)/qdbusserver.cpp        \
-	$(srcdir)/qdbusproxy.cpp         \
-	$(srcdir)/qdbusdata.cpp          \
-	$(srcdir)/qdbusdatalist.cpp      \
-	$(srcdir)/qdbusobjectpath.cpp    \
-	$(srcdir)/qdbusdataconverter.cpp
-
-$(srcdir)/qdbusserver.cpp: qdbusserver.moc
-$(srcdir)/qdbusconnection.cpp: qdbusconnection.moc
-$(srcdir)/qdbusproxy.cpp: qdbusproxy.moc
+	dbus/qdbusproxy.h      \
+	dbus/qdbusserver.h     \
+	qdbusconnection_p.h    \
+	qdbusconnection.cpp    \
+	qdbuserror.cpp         \
+	qdbusintegrator.cpp    \
+	qdbusmarshall.cpp      \
+	qdbusmessage.cpp       \
+	qdbusserver.cpp        \
+	qdbusproxy.cpp         \
+	qdbusdata.cpp          \
+	qdbusdatalist.cpp      \
+	qdbusobjectpath.cpp    \
+	qdbusdataconverter.cpp
+
+qdbusserver.lo: qdbusserver.moc
+qdbusconnection.lo: qdbusconnection.moc
+qdbusproxy.lo: qdbusproxy.moc
 
 CLEANFILES = qdbusserver.moc qdbusconnection.moc qdbusproxy.moc
 
@@ -59,9 +59,6 @@ qdbusconnection.moc: qdbusconnection_p.h
 qdbusproxy.moc: dbus/qdbusproxy.h
 	$(MOC) -o qdbusproxy.moc $(srcdir)/dbus/qdbusproxy.h
 
-%.moc: %.h
-	$(MOC) $< > $@
-
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = dbus-1-qt3.pc

Places

File BRANCH_UPDATE.diff of Package libdbus-1-qt3-0 (Revision add045c8abcff69a718da132a71e02ce)

Places