Long live Qt 4.5!

22 files changed, 3472 insertions, 0 deletions

diff --git a/tools/qdbus/qdbus.pro b/tools/qdbus/qdbus.pro
new file mode 100644
index 0000000..01cd246
--- /dev/null
+++ b/tools/qdbus/qdbus.pro
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS = qdbus qdbusxml2cpp qdbuscpp2xml qdbusviewer
diff --git a/tools/qdbus/qdbus/qdbus.cpp b/tools/qdbus/qdbus/qdbus.cpp
new file mode 100644
index 0000000..d290eab
--- /dev/null
+++ b/tools/qdbus/qdbus/qdbus.cpp
@@ -0,0 +1,483 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QStringList>
+#include <QtCore/qmetaobject.h>
+#include <QtXml/QDomDocument>
+#include <QtXml/QDomElement>
+#include <QtDBus/QtDBus>
+#include <private/qdbusutil_p.h>
+
+static QDBusConnection connection(QLatin1String(""));
+static bool printArgumentsLiterally = false;
+
+static void showUsage()
+{
+    printf("Usage: qdbus [--system] [--literal] [servicename] [path] [method] [args]\n"
+           "\n"
+           "  servicename       the service to connect to (e.g., org.freedesktop.DBus)\n"
+           "  path              the path to the object (e.g., /)\n"
+           "  method            the method to call, with or without the interface\n"
+           "  args              arguments to pass to the call\n"
+           "With 0 arguments, qdbus will list the services available on the bus\n"
+           "With just the servicename, qdbus will list the object paths available on the service\n"
+           "With service name and object path, qdbus will list the methods, signals and properties available on the object\n"
+           "\n"
+           "Options:\n"
+           "  --system          connect to the system bus\n"
+           "  --literal         print replies literally\n");
+}
+
+static void printArg(const QVariant &v)
+{
+    if (printArgumentsLiterally) {
+        printf("%s\n", qPrintable(QDBusUtil::argumentToString(v)));
+        return;
+    }
+
+    if (v.userType() == QVariant::StringList) {
+        foreach (QString s, v.toStringList())
+            printf("%s\n", qPrintable(s));
+    } else if (v.userType() == QVariant::List) {
+        foreach (const QVariant &var, v.toList())
+            printArg(var);
+    } else if (v.userType() == QVariant::Map) {
+        const QVariantMap map = v.toMap();
+        QVariantMap::ConstIterator it = map.constBegin();
+        for ( ; it != map.constEnd(); ++it) {
+            printf("%s: ", qPrintable(it.key()));
+            printArg(it.value());
+        }
+    } else if (v.userType() == qMetaTypeId<QDBusVariant>()) {
+        printArg(qvariant_cast<QDBusVariant>(v).variant());
+    } else if (v.userType() == qMetaTypeId<QDBusArgument>()) {
+        QDBusArgument arg = qvariant_cast<QDBusArgument>(v);
+        if (arg.currentSignature() == QLatin1String("av"))
+            printArg(qdbus_cast<QVariantList>(arg));
+        else if (arg.currentSignature() == QLatin1String("a{sv}"))
+            printArg(qdbus_cast<QVariantMap>(arg));
+        else
+            printf("qdbus: I don't know how to display an argument of type '%s'\n",
+                   qPrintable(arg.currentSignature()));
+    } else {
+        printf("%s\n", qPrintable(v.toString()));
+    }
+}
+
+static void listObjects(const QString &service, const QString &path)
+{
+    QDBusInterface iface(service, path.isEmpty() ? QLatin1String("/") : path,
+                         QLatin1String("org.freedesktop.DBus.Introspectable"), connection);
+    if (!iface.isValid()) {
+        QDBusError err(iface.lastError());
+        fprintf(stderr, "Cannot introspect object %s at %s:\n%s (%s)\n",
+                qPrintable(path.isEmpty() ? QString(QLatin1String("/")) : path), qPrintable(service),
+                qPrintable(err.name()), qPrintable(err.message()));
+        exit(1);
+    }
+    QDBusReply<QString> xml = iface.call(QLatin1String("Introspect"));
+
+    if (!xml.isValid())
+        return;                 // silently
+
+    QDomDocument doc;
+    doc.setContent(xml);
+    QDomElement node = doc.documentElement();
+    QDomElement child = node.firstChildElement();
+    while (!child.isNull()) {
+        if (child.tagName() == QLatin1String("node")) {
+            QString sub = path + QLatin1Char('/') + child.attribute(QLatin1String("name"));
+            printf("%s\n", qPrintable(sub));
+            listObjects(service, sub);
+        }
+        child = child.nextSiblingElement();
+    }
+}
+
+static void listInterface(const QString &service, const QString &path, const QString &interface)
+{
+    QDBusInterface iface(service, path, interface, connection);
+    if (!iface.isValid()) {
+        QDBusError err(iface.lastError());
+        fprintf(stderr, "Interface '%s' not available in object %s at %s:\n%s (%s)\n",
+                qPrintable(interface), qPrintable(path), qPrintable(service),
+                qPrintable(err.name()), qPrintable(err.message()));
+        exit(1);
+    }
+    const QMetaObject *mo = iface.metaObject();
+
+    // properties
+    for (int i = mo->propertyOffset(); i < mo->propertyCount(); ++i) {
+        QMetaProperty mp = mo->property(i);
+        printf("property ");
+
+        if (mp.isReadable() && mp.isWritable())
+            printf("readwrite");
+        else if (mp.isReadable())
+            printf("read");
+        else
+            printf("write");
+
+        printf(" %s %s.%s\n", mp.typeName(), qPrintable(interface), mp.name());
+    }
+
+    // methods (signals and slots)
+    for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
+        QMetaMethod mm = mo->method(i);
+
+        QByteArray signature = mm.signature();
+        signature.truncate(signature.indexOf('('));
+        printf("%s %s%s%s %s.%s(",
+               mm.methodType() == QMetaMethod::Signal ? "signal" : "method",
+               mm.tag(), *mm.tag() ? " " : "",
+               *mm.typeName() ? mm.typeName() : "void",
+               qPrintable(interface), signature.constData());
+
+        QList<QByteArray> types = mm.parameterTypes();
+        QList<QByteArray> names = mm.parameterNames();
+        bool first = true;
+        for (int i = 0; i < types.count(); ++i) {
+            printf("%s%s",
+                   first ? "" : ", ",
+                   types.at(i).constData());
+            if (!names.at(i).isEmpty())
+                printf(" %s", names.at(i).constData());
+            first = false;
+        }
+        printf(")\n");
+    }
+}
+
+static void listAllInterfaces(const QString &service, const QString &path)
+{
+    QDBusInterface iface(service, path, QLatin1String("org.freedesktop.DBus.Introspectable"), connection);
+    if (!iface.isValid()) {
+        QDBusError err(iface.lastError());
+        fprintf(stderr, "Cannot introspect object %s at %s:\n%s (%s)\n",
+                qPrintable(path), qPrintable(service),
+                qPrintable(err.name()), qPrintable(err.message()));
+        exit(1);
+    }
+    QDBusReply<QString> xml = iface.call(QLatin1String("Introspect"));
+
+    if (!xml.isValid())
+        return;                 // silently
+
+    QDomDocument doc;
+    doc.setContent(xml);
+    QDomElement node = doc.documentElement();
+    QDomElement child = node.firstChildElement();
+    while (!child.isNull()) {
+        if (child.tagName() == QLatin1String("interface")) {
+            QString ifaceName = child.attribute(QLatin1String("name"));
+            if (QDBusUtil::isValidInterfaceName(ifaceName))
+                listInterface(service, path, ifaceName);
+            else {
+                qWarning("Invalid D-BUS interface name '%s' found while parsing introspection",
+                         qPrintable(ifaceName));
+            }
+        }
+        child = child.nextSiblingElement();
+    }
+}
+
+static QStringList readList(QStringList &args)
+{
+    args.takeFirst();
+
+    QStringList retval;
+    while (!args.isEmpty() && args.at(0) != QLatin1String(")"))
+        retval += args.takeFirst();
+
+    if (args.value(0) == QLatin1String(")"))
+        args.takeFirst();
+
+    return retval;
+}
+
+static void placeCall(const QString &service, const QString &path, const QString &interface,
+               const QString &member, QStringList args)
+{
+    QDBusInterface iface(service, path, interface, connection);
+    if (!iface.isValid()) {
+        QDBusError err(iface.lastError());
+        fprintf(stderr, "Interface '%s' not available in object %s at %s:\n%s (%s)\n",
+                qPrintable(interface), qPrintable(path), qPrintable(service),
+                qPrintable(err.name()), qPrintable(err.message()));
+        exit(1);
+    }
+
+    QVariantList params;
+    if (!args.isEmpty()) {
+        const QMetaObject *mo = iface.metaObject();
+        QByteArray match = member.toLatin1();
+        match += '(';
+
+        int midx = -1;
+        for (int i = mo->methodOffset(); i < mo->methodCount(); ++i) {
+            QMetaMethod mm = mo->method(i);
+            QByteArray signature = mm.signature();
+            if (signature.startsWith(match)) {
+                midx = i;
+                break;
+            }
+         }
+
+        if (midx == -1) {
+            fprintf(stderr, "Cannot find '%s.%s' in object %s at %s\n",
+                    qPrintable(interface), qPrintable(member), qPrintable(path),
+                    qPrintable(service));
+            exit(1);
+        }
+
+        QMetaMethod mm = mo->method(midx);
+        QList<QByteArray> types = mm.parameterTypes();
+        for (int i = 0; i < types.count(); ++i) {
+            if (types.at(i).endsWith('&')) {
+                // reference (and not a reference to const): output argument
+                // we're done with the inputs
+                while (types.count() > i)
+                    types.removeLast();
+                break;
+            }
+        }
+
+        for (int i = 0; !args.isEmpty() && i < types.count(); ++i) {
+            int id = QVariant::nameToType(types.at(i));
+            if (id == QVariant::UserType)
+                id = QMetaType::type(types.at(i));
+            Q_ASSERT(id);
+
+            QVariant p;
+            QString argument;
+            if ((id == QVariant::List || id == QVariant::StringList)
+                 && args.at(0) == QLatin1String("("))
+                p = readList(args);
+            else
+                p = argument = args.takeFirst();
+
+            if (id == int(QMetaType::UChar)) {
+                // special case: QVariant::convert doesn't convert to/from
+                // UChar because it can't decide if it's a character or a number
+                p = qVariantFromValue<uchar>(p.toUInt());
+            } else if (id < int(QMetaType::User) && id != int(QVariant::Map)) {
+                p.convert(QVariant::Type(id));
+                if (p.type() == QVariant::Invalid) {
+                    fprintf(stderr, "Could not convert '%s' to type '%s'.\n",
+                            qPrintable(argument), types.at(i).constData());
+                    exit(1);
+                }
+            } else if (id == qMetaTypeId<QDBusVariant>()) {
+                QDBusVariant tmp(p);
+                p = qVariantFromValue(tmp);
+            } else if (id == qMetaTypeId<QDBusObjectPath>()) {
+                QDBusObjectPath path(argument);
+                if (path.path().isNull()) {
+                    fprintf(stderr, "Cannot pass argument '%s' because it is not a valid object path.\n",
+                            qPrintable(argument));
+                    exit(1);
+                }
+                p = qVariantFromValue(path);
+            } else if (id == qMetaTypeId<QDBusSignature>()) {
+                QDBusSignature sig(argument);
+                if (sig.signature().isNull()) {
+                    fprintf(stderr, "Cannot pass argument '%s' because it is not a valid signature.\n",
+                            qPrintable(argument));
+                    exit(1);
+                }
+                p = qVariantFromValue(sig);
+            } else {
+                fprintf(stderr, "Sorry, can't pass arg of type '%s'.\n",
+                        types.at(i).constData());
+                exit(1);
+            }
+            params += p;
+        }
+        if (params.count() != types.count() || !args.isEmpty()) {
+            fprintf(stderr, "Invalid number of parameters\n");
+            exit(1);
+        }
+    }
+
+    QDBusMessage reply = iface.callWithArgumentList(QDBus::Block, member, params);
+    if (reply.type() == QDBusMessage::ErrorMessage) {
+        QDBusError err = reply;
+        printf("Error: %s\n%s\n", qPrintable(err.name()), qPrintable(err.message()));
+        exit(2);
+    } else if (reply.type() != QDBusMessage::ReplyMessage) {
+        fprintf(stderr, "Invalid reply type %d\n", int(reply.type()));
+        exit(1);
+    }
+
+    foreach (QVariant v, reply.arguments())
+        printArg(v);
+
+    exit(0);
+}
+
+static bool globServices(QDBusConnectionInterface *bus, const QString &glob)
+{
+    QRegExp pattern(glob, Qt::CaseSensitive, QRegExp::Wildcard);
+    if (!pattern.isValid())
+        return false;
+
+    QStringList names = bus->registeredServiceNames();
+    names.sort();
+    foreach (const QString &name, names)
+        if (pattern.exactMatch(name))
+            printf("%s\n", qPrintable(name));
+
+    return true;
+}
+
+static void printAllServices(QDBusConnectionInterface *bus)
+{
+    const QStringList services = bus->registeredServiceNames();
+    QMap<QString, QStringList> servicesWithAliases;
+
+    foreach (QString serviceName, services) {
+        QDBusReply<QString> reply = bus->serviceOwner(serviceName);
+        QString owner = reply;
+        if (owner.isEmpty())
+            owner = serviceName;
+        servicesWithAliases[owner].append(serviceName);
+    }
+
+    for (QMap<QString,QStringList>::const_iterator it = servicesWithAliases.constBegin();
+         it != servicesWithAliases.constEnd(); ++it) {
+        QStringList names = it.value();
+        names.sort();
+        printf("%s\n", qPrintable(names.join(QLatin1String("\n "))));
+    }
+}
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+    QStringList args = app.arguments();
+    args.takeFirst();
+
+    bool connectionOpened = false;
+    while (!args.isEmpty() && args.at(0).startsWith(QLatin1Char('-'))) {
+        QString arg = args.takeFirst();
+        if (arg == QLatin1String("--system")) {
+            connection = QDBusConnection::systemBus();
+            connectionOpened = true;
+        } else if (arg == QLatin1String("--literal")) {
+            printArgumentsLiterally = true;
+        } else if (arg == QLatin1String("--help")) {
+            showUsage();
+            return 0;
+        }
+    }
+
+    if (!connectionOpened)
+        connection = QDBusConnection::sessionBus();
+
+    if (!connection.isConnected()) {
+        fprintf(stderr, "Could not connect to D-Bus server: %s: %s\n",
+                qPrintable(connection.lastError().name()),
+                qPrintable(connection.lastError().message()));
+        return 1;
+    }
+
+    QDBusConnectionInterface *bus = connection.interface();
+    if (args.isEmpty()) {
+        printAllServices(bus);
+        exit(0);
+    }
+
+    QString service = args.takeFirst();
+    if (!QDBusUtil::isValidBusName(service)) {
+        if (service.contains(QLatin1Char('*'))) {
+            if (globServices(bus, service))
+                return 0;
+        }
+        fprintf(stderr, "Service '%s' is not a valid name.\n", qPrintable(service));
+        exit(1);
+    }
+    if (!bus->isServiceRegistered(service)) {
+        fprintf(stderr, "Service '%s' does not exist.\n", qPrintable(service));
+        exit(1);
+    }
+
+    if (args.isEmpty()) {
+        printf("/\n");
+        listObjects(service, QString());
+        exit(0);
+    }
+
+    QString path = args.takeFirst();
+    if (!QDBusUtil::isValidObjectPath(path)) {
+        fprintf(stderr, "Path '%s' is not a valid path name.\n", qPrintable(path));
+        exit(1);
+    }
+    if (args.isEmpty()) {
+        listAllInterfaces(service, path);
+        exit(0);
+    }
+
+    QString interface = args.takeFirst();
+    QString member;
+    int pos = interface.lastIndexOf(QLatin1Char('.'));
+    if (pos == -1) {
+        member = interface;
+        interface.clear();
+    } else {
+        member = interface.mid(pos + 1);
+        interface.truncate(pos);
+    }
+    if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface)) {
+        fprintf(stderr, "Interface '%s' is not a valid interface name.\n", qPrintable(interface));
+        exit(1);
+    }
+    if (!QDBusUtil::isValidMemberName(member)) {
+        fprintf(stderr, "Method name '%s' is not a valid member name.\n", qPrintable(member));
+        exit(1);
+    }
+
+    placeCall(service, path, interface, member, args);
+}
+
diff --git a/tools/qdbus/qdbus/qdbus.pro b/tools/qdbus/qdbus/qdbus.pro
new file mode 100644
index 0000000..ea732ef
--- /dev/null
+++ b/tools/qdbus/qdbus/qdbus.pro
@@ -0,0 +1,10 @@
+SOURCES = qdbus.cpp
+DESTDIR = ../../../bin
+TARGET = qdbus
+QT = core xml
+CONFIG += qdbus
+CONFIG -= app_bundle
+win32:CONFIG += console
+
+target.path=$$[QT_INSTALL_BINS]
+INSTALLS += target
diff --git a/tools/qdbus/qdbuscpp2xml/qdbuscpp2xml.cpp b/tools/qdbus/qdbuscpp2xml/qdbuscpp2xml.cpp
new file mode 100644
index 0000000..9e789b0
--- /dev/null
+++ b/tools/qdbus/qdbuscpp2xml/qdbuscpp2xml.cpp
@@ -0,0 +1,446 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QByteArray>
+#include <QString>
+#include <QVarLengthArray>
+#include <QFile>
+#include <QProcess>
+#include <QMetaObject>
+#include <QList>
+#include <QRegExp>
+#include <QCoreApplication>
+#include <QLibraryInfo>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "qdbusconnection.h"    // for the Export* flags
+
+// copied from dbus-protocol.h:
+static const char docTypeHeader[] =
+    "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\" "
+    "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n";
+
+// in qdbusxmlgenerator.cpp
+QT_BEGIN_NAMESPACE
+extern QDBUS_EXPORT QString qDBusGenerateMetaObjectXml(QString interface, const QMetaObject *mo,
+                                                       const QMetaObject *base, int flags);
+QT_END_NAMESPACE
+
+#define PROGRAMNAME     "qdbuscpp2xml"
+#define PROGRAMVERSION  "0.1"
+#define PROGRAMCOPYRIGHT "Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)."
+
+static QString outputFile;
+static int flags;
+
+static const char help[] =
+    "Usage: " PROGRAMNAME " [options...] [files...]\n"
+    "Parses the C++ source or header file containing a QObject-derived class and\n"
+    "produces the D-Bus Introspection XML."
+    "\n"
+    "Options:\n"
+    "  -p|-s|-m       Only parse scriptable Properties, Signals and Methods (slots)\n"
+    "  -P|-S|-M       Parse all Properties, Signals and Methods (slots)\n"
+    "  -a             Output all scriptable contents (equivalent to -psm)\n"
+    "  -A             Output all contents (equivalent to -PSM)\n"
+    "  -o <filename>  Write the output to file <filename>\n"
+    "  -h             Show this information\n"
+    "  -V             Show the program version and quit.\n"
+    "\n";
+
+class MocParser
+{
+    void parseError();
+    QByteArray readLine();
+    void loadIntData(uint *&data);
+    void loadStringData(char *&stringdata);
+
+    QIODevice *input;
+    const char *filename;
+    int lineNumber;
+public:
+    ~MocParser();
+    void parse(const char *filename, QIODevice *input, int lineNumber = 0);
+
+    QList<QMetaObject> objects;
+};
+
+void MocParser::parseError()
+{
+    fprintf(stderr, PROGRAMNAME ": error parsing input file '%s' line %d \n", filename, lineNumber);
+    exit(1);
+}
+
+QByteArray MocParser::readLine()
+{
+    ++lineNumber;
+    return input->readLine();
+}
+
+void MocParser::loadIntData(uint *&data)
+{
+    data = 0;                   // initialise
+    QVarLengthArray<uint> array;
+    QRegExp rx(QLatin1String("(\\d+|0x[0-9abcdef]+)"), Qt::CaseInsensitive);
+
+    while (!input->atEnd()) {
+        QString line = QLatin1String(readLine());
+        int pos = line.indexOf(QLatin1String("//"));
+        if (pos != -1)
+            line.truncate(pos); // drop comments
+
+        if (line == QLatin1String("};\n")) {
+            // end of data
+            data = new uint[array.count()];
+            memcpy(data, array.data(), array.count() * sizeof(*data));
+            return;
+        }
+
+        pos = 0;
+        while ((pos = rx.indexIn(line, pos)) != -1) {
+            QString num = rx.cap(1);
+            if (num.startsWith(QLatin1String("0x")))
+                array.append(num.mid(2).toUInt(0, 16));
+            else
+                array.append(num.toUInt());
+            pos += rx.matchedLength();
+        }
+    }
+
+    parseError();
+}
+
+void MocParser::loadStringData(char *&stringdata)
+{
+    stringdata = 0;
+    QVarLengthArray<char, 1024> array;
+
+    while (!input->atEnd()) {
+        QByteArray line = readLine();
+        if (line == "};\n") {
+            // end of data
+            stringdata = new char[array.count()];
+            memcpy(stringdata, array.data(), array.count() * sizeof(*stringdata));
+            return;
+        }
+
+        int start = line.indexOf('"');
+        if (start == -1)
+            parseError();
+
+        int len = line.length() - 1;
+        line.truncate(len);     // drop ending \n
+        if (line.at(len - 1) != '"')
+            parseError();
+
+        --len;
+        ++start;
+        for ( ; start < len; ++start)
+            if (line.at(start) == '\\') {
+                // parse escaped sequence
+                ++start;
+                if (start == len)
+                    parseError();
+
+                QChar c(QLatin1Char(line.at(start)));
+                if (!c.isDigit()) {
+                    switch (c.toLatin1()) {
+                    case 'a':
+                        array.append('\a');
+                        break;
+                    case 'b':
+                        array.append('\b');
+                        break;
+                    case 'f':
+                        array.append('\f');
+                        break;
+                    case 'n':
+                        array.append('\n');
+                        break;
+                    case 'r':
+                        array.append('\r');
+                        break;
+                    case 't':
+                        array.append('\t');
+                        break;
+                    case 'v':
+                        array.append('\v');
+                        break;
+                    case '\\':
+                    case '?':
+                    case '\'':
+                    case '"':
+                        array.append(c.toLatin1());
+                        break;
+
+                    case 'x':
+                        if (start + 2 <= len)
+                            parseError();
+                        array.append(char(line.mid(start + 1, 2).toInt(0, 16)));
+                        break;
+
+                    default:
+                        array.append(c.toLatin1());
+                        fprintf(stderr, PROGRAMNAME ": warning: invalid escape sequence '\\%c' found in input",
+                                c.toLatin1());
+                    }
+                } else {
+                    // octal
+                    QRegExp octal(QLatin1String("([0-7]+)"));
+                    if (octal.indexIn(QLatin1String(line), start) == -1)
+                        parseError();
+                    array.append(char(octal.cap(1).toInt(0, 8)));
+                }
+            } else {
+                array.append(line.at(start));
+            }
+    }
+
+    parseError();
+}
+
+void MocParser::parse(const char *fname, QIODevice *io, int lineNum)
+{
+    filename = fname;
+    input = io;
+    lineNumber = lineNum;
+
+    while (!input->atEnd()) {
+        QByteArray line = readLine();
+        if (line.startsWith("static const uint qt_meta_data_")) {
+            // start of new class data
+            uint *data;
+            loadIntData(data);
+
+            // find the start of the string data
+            do {
+                line = readLine();
+                if (input->atEnd())
+                    parseError();
+            } while (!line.startsWith("static const char qt_meta_stringdata_"));
+
+            char *stringdata;
+            loadStringData(stringdata);
+
+            QMetaObject mo;
+            mo.d.superdata = &QObject::staticMetaObject;
+            mo.d.stringdata = stringdata;
+            mo.d.data = data;
+            mo.d.extradata = 0;
+            objects.append(mo);
+        }
+    }
+
+    fname = 0;
+    input = 0;
+}
+
+MocParser::~MocParser()
+{
+    foreach (QMetaObject mo, objects) {
+        delete const_cast<char *>(mo.d.stringdata);
+        delete const_cast<uint *>(mo.d.data);
+    }
+}
+
+static void showHelp()
+{
+    printf("%s", help);
+    exit(0);
+}
+
+static void showVersion()
+{
+    printf("%s version %s\n", PROGRAMNAME, PROGRAMVERSION);
+    printf("D-Bus QObject-to-XML converter\n");
+    exit(0);
+}
+
+static void parseCmdLine(QStringList &arguments)
+{
+    for (int i = 1; i < arguments.count(); ++i) {
+        const QString arg = arguments.at(i);
+
+        if (arg == QLatin1String("--help"))
+            showHelp();
+
+        if (!arg.startsWith(QLatin1Char('-')))
+            continue;
+
+        char c = arg.count() == 2 ? arg.at(1).toLatin1() : char(0);
+        switch (c) {
+        case 'P':
+            flags |= QDBusConnection::ExportNonScriptableProperties;
+            // fall through
+        case 'p':
+            flags |= QDBusConnection::ExportScriptableProperties;
+            break;
+
+        case 'S':
+            flags |= QDBusConnection::ExportNonScriptableSignals;
+            // fall through
+        case 's':
+            flags |= QDBusConnection::ExportScriptableSignals;
+            break;
+
+        case 'M':
+            flags |= QDBusConnection::ExportNonScriptableSlots;
+            // fall through
+        case 'm':
+            flags |= QDBusConnection::ExportScriptableSlots;
+            break;
+
+        case 'A':
+            flags |= QDBusConnection::ExportNonScriptableContents;
+            // fall through
+        case 'a':
+            flags |= QDBusConnection::ExportScriptableContents;
+            break;
+
+        case 'o':
+            if (arguments.count() < i + 2 || arguments.at(i + 1).startsWith(QLatin1Char('-'))) {
+                printf("-o expects a filename\n");
+                exit(1);
+            }
+            outputFile = arguments.takeAt(i + 1);
+            break;
+
+        case 'h':
+        case '?':
+            showHelp();
+            break;
+
+        case 'V':
+            showVersion();
+            break;
+
+        default:
+            printf("unknown option: \"%s\"\n", qPrintable(arg));
+            exit(1);
+        }
+    }
+
+    if (flags == 0)
+        flags = QDBusConnection::ExportScriptableContents
+                | QDBusConnection::ExportNonScriptableContents;
+}
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+    QStringList args = app.arguments();
+
+    MocParser parser;
+    parseCmdLine(args);
+
+    for (int i = 1; i < args.count(); ++i) {
+        const QString arg = args.at(i);
+        if (arg.startsWith(QLatin1Char('-')))
+            continue;
+
+        QFile f(arg);
+        if (!f.open(QIODevice::ReadOnly|QIODevice::Text)) {
+            fprintf(stderr, PROGRAMNAME ": could not open '%s': %s\n",
+                    qPrintable(arg), qPrintable(f.errorString()));
+            return 1;
+        }
+
+        f.readLine();
+
+        QByteArray line = f.readLine();
+        if (line.contains("Meta object code from reading C++ file"))
+            // this is a moc-generated file
+            parser.parse(argv[i], &f, 3);
+        else {
+            // run moc on this file
+            QProcess proc;
+            proc.start(QLibraryInfo::location(QLibraryInfo::BinariesPath) + QLatin1String("/moc"), QStringList() << QFile::decodeName(argv[i]), QIODevice::ReadOnly | QIODevice::Text);
+
+            if (!proc.waitForStarted()) {
+                fprintf(stderr, PROGRAMNAME ": could not execute moc! Aborting.\n");
+                return 1;
+            }
+
+            proc.closeWriteChannel();
+
+            if (!proc.waitForFinished() || proc.exitStatus() != QProcess::NormalExit ||
+                proc.exitCode() != 0) {
+                // output the moc errors:
+                fprintf(stderr, "%s", proc.readAllStandardError().constData());
+                fprintf(stderr, PROGRAMNAME ": exit code %d from moc. Aborting\n", proc.exitCode());
+                return 1;
+            }
+            fprintf(stderr, "%s", proc.readAllStandardError().constData());
+
+            parser.parse(argv[i], &proc, 1);
+        }
+
+        f.close();
+    }
+
+    QFile output;
+    if (outputFile.isEmpty()) {
+        output.open(stdout, QIODevice::WriteOnly);
+    } else {
+        output.setFileName(outputFile);
+        if (!output.open(QIODevice::WriteOnly)) {
+            fprintf(stderr, PROGRAMNAME ": could not open output file '%s': %s",
+                    qPrintable(outputFile), qPrintable(output.errorString()));
+            return 1;
+        }
+    }
+
+    output.write(docTypeHeader);
+    output.write("<node>\n");
+    foreach (QMetaObject mo, parser.objects) {
+        QString xml = qDBusGenerateMetaObjectXml(QString(), &mo, &QObject::staticMetaObject,
+                                                 flags);
+        output.write(xml.toLocal8Bit());
+    }
+    output.write("</node>\n");
+
+    return 0;
+}
+
diff --git a/tools/qdbus/qdbuscpp2xml/qdbuscpp2xml.pro b/tools/qdbus/qdbuscpp2xml/qdbuscpp2xml.pro
new file mode 100644
index 0000000..9ee1d37
--- /dev/null
+++ b/tools/qdbus/qdbuscpp2xml/qdbuscpp2xml.pro
@@ -0,0 +1,10 @@
+SOURCES = qdbuscpp2xml.cpp
+DESTDIR = ../../../bin
+TARGET = qdbuscpp2xml
+QT = core xml
+CONFIG += qdbus
+CONFIG -= app_bundle
+win32:CONFIG += console
+
+target.path=$$[QT_INSTALL_BINS]
+INSTALLS += target
diff --git a/tools/qdbus/qdbusviewer/Info_mac.plist b/tools/qdbus/qdbusviewer/Info_mac.plist
new file mode 100644
index 0000000..b351409
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/Info_mac.plist
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd">
+<plist version="0.9">
+<dict>
+	<key>CFBundleIconFile</key>
+	<string>@ICON@</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+        <key>CFBundleGetInfoString</key>
+	<string>Created by Qt/QMake</string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleIdentifier</key>
+	<string>com.trolltech.dbusviewer</string>
+	<key>CFBundleExecutable</key>
+	<string>@EXECUTABLE@</string>
+</dict>
+</plist>
diff --git a/tools/qdbus/qdbusviewer/images/qdbusviewer-128.png b/tools/qdbus/qdbusviewer/images/qdbusviewer-128.png
new file mode 100644
index 0000000..0754912
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/images/qdbusviewer-128.png
diff --git a/tools/qdbus/qdbusviewer/images/qdbusviewer.icns b/tools/qdbus/qdbusviewer/images/qdbusviewer.icns
new file mode 100644
index 0000000..b6f39b9
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/images/qdbusviewer.icns
diff --git a/tools/qdbus/qdbusviewer/images/qdbusviewer.ico b/tools/qdbus/qdbusviewer/images/qdbusviewer.ico
new file mode 100644
index 0000000..49edb09
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/images/qdbusviewer.ico
diff --git a/tools/qdbus/qdbusviewer/images/qdbusviewer.png b/tools/qdbus/qdbusviewer/images/qdbusviewer.png
new file mode 100644
index 0000000..5a8c5a3
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/images/qdbusviewer.png
diff --git a/tools/qdbus/qdbusviewer/main.cpp b/tools/qdbus/qdbusviewer/main.cpp
new file mode 100644
index 0000000..b670337
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/main.cpp
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtGui/qapplication.h>
+#include <QtGui/qmainwindow.h>
+#include <QtGui/qtabwidget.h>
+#include <QtDBus/qdbusconnection.h>
+#include "qdbusviewer.h"
+
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+    QApplication app(argc, argv);
+    QMainWindow mw;
+#ifndef Q_WS_MAC
+    app.setWindowIcon(QIcon(QLatin1String(":/trolltech/qdbusviewer/images/qdbusviewer.png")));
+#else
+    mw.setWindowTitle(qApp->translate("QtDBusViewer", "Qt D-Bus Viewer"));
+#endif
+
+
+    QTabWidget *mainWidget = new QTabWidget;
+    mw.setCentralWidget(mainWidget);
+    QDBusViewer *sessionBusViewer = new QDBusViewer(QDBusConnection::sessionBus());
+    QDBusViewer *systemBusViewer = new QDBusViewer(QDBusConnection::systemBus());
+    mainWidget->addTab(sessionBusViewer, QObject::tr("Session Bus"));
+    mainWidget->addTab(systemBusViewer, QObject::tr("System Bus"));
+
+    QMenu *fileMenu = mw.menuBar()->addMenu(QObject::tr("&File"));
+    QAction *quitAction = fileMenu->addAction(QObject::tr("&Quit"), &mw, SLOT(close()));
+    Q_UNUSED(quitAction);
+
+    QMenu *helpMenu = mw.menuBar()->addMenu(QObject::tr("&Help"));
+    QAction *aboutAction = helpMenu->addAction(QObject::tr("&About"));
+    aboutAction->setMenuRole(QAction::AboutRole);
+    QObject::connect(aboutAction, SIGNAL(triggered()), sessionBusViewer, SLOT(about()));
+
+    QAction *aboutQtAction = helpMenu->addAction(QObject::tr("About &Qt"));
+    aboutQtAction->setMenuRole(QAction::AboutQtRole);
+    QObject::connect(aboutQtAction, SIGNAL(triggered()), &app, SLOT(aboutQt()));
+
+    mw.show();
+
+    return app.exec();
+}
+
diff --git a/tools/qdbus/qdbusviewer/propertydialog.cpp b/tools/qdbus/qdbusviewer/propertydialog.cpp
new file mode 100644
index 0000000..6359cd7
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/propertydialog.cpp
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "propertydialog.h"
+
+#include <QHeaderView>
+#include <QLayout>
+#include <QDebug>
+
+PropertyDialog::PropertyDialog(QWidget *parent, Qt::WindowFlags f)
+    : QDialog(parent, f)
+{
+    buttonBox = new QDialogButtonBox;
+    propertyTable = new QTableWidget;
+    label = new QLabel;
+
+    buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+    propertyTable->setColumnCount(2);
+    const QStringList labels = QStringList() << QLatin1String("Name") << QLatin1String("Value");
+    propertyTable->setHorizontalHeaderLabels(labels);
+    propertyTable->horizontalHeader()->setStretchLastSection(true);
+    propertyTable->setEditTriggers(QAbstractItemView::AllEditTriggers);
+
+    connect(buttonBox, SIGNAL(accepted()), SLOT(accept()), Qt::QueuedConnection);
+    connect(buttonBox, SIGNAL(rejected()), SLOT(reject()), Qt::QueuedConnection);
+
+    QVBoxLayout *layout = new QVBoxLayout(this);
+    layout->addWidget(label);
+    layout->addWidget(propertyTable);
+    layout->addWidget(buttonBox);
+}
+
+void PropertyDialog::setInfo(const QString &caption)
+{
+    label->setText(caption);
+}
+
+void PropertyDialog::addProperty(const QString &aname, QVariant::Type type)
+{
+    int rowCount = propertyTable->rowCount();
+    propertyTable->setRowCount(rowCount + 1);
+
+    QString name = aname;
+    if (name.isEmpty())
+        name = QLatin1String("argument ") + QString::number(rowCount + 1);
+    name += QLatin1String(" (");
+    name += QLatin1String(QVariant::typeToName(type));
+    name += QLatin1String(")");
+    QTableWidgetItem *nameItem = new QTableWidgetItem(name);
+    nameItem->setFlags(nameItem->flags() &
+            ~(Qt::ItemIsEditable | Qt::ItemIsSelectable));
+    propertyTable->setItem(rowCount, 0, nameItem);
+
+    QTableWidgetItem *valueItem = new QTableWidgetItem;
+    valueItem->setData(Qt::DisplayRole, QVariant(type));
+    propertyTable->setItem(rowCount, 1, valueItem);
+}
+
+int PropertyDialog::exec()
+{
+    propertyTable->resizeColumnToContents(0);
+    propertyTable->setFocus();
+    propertyTable->setCurrentCell(0, 1);
+    return QDialog::exec();
+}
+
+QList<QVariant> PropertyDialog::values() const
+{
+    QList<QVariant> result;
+
+    for (int i = 0; i < propertyTable->rowCount(); ++i)
+        result << propertyTable->item(i, 1)->data(Qt::EditRole);
+
+    return result;
+}
+
diff --git a/tools/qdbus/qdbusviewer/propertydialog.h b/tools/qdbus/qdbusviewer/propertydialog.h
new file mode 100644
index 0000000..2ba30e17
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/propertydialog.h
@@ -0,0 +1,70 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef PROPERTYDIALOG_H
+#define PROPERTYDIALOG_H
+
+#include <QLabel>
+#include <QDialog>
+#include <QTableWidget>
+#include <QDialogButtonBox>
+
+class PropertyDialog: public QDialog
+{
+    Q_OBJECT
+public:
+    explicit PropertyDialog(QWidget *parent = 0, Qt::WindowFlags f = 0);
+
+    void addProperty(const QString &name, QVariant::Type type);
+    void setInfo(const QString &caption);
+
+    QList<QVariant> values() const;
+
+    int exec();
+
+private:
+    QLabel *label;
+    QTableWidget *propertyTable;
+    QDialogButtonBox *buttonBox;
+};
+
+#endif
+
diff --git a/tools/qdbus/qdbusviewer/qdbusmodel.cpp b/tools/qdbus/qdbusviewer/qdbusmodel.cpp
new file mode 100644
index 0000000..88e3524
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusmodel.cpp
@@ -0,0 +1,336 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdbusmodel.h"
+
+#include <QtCore/qvector.h>
+#include <QtXml/QtXml>
+
+struct QDBusItem
+{
+    inline QDBusItem(QDBusModel::Type aType, const QString &aName, QDBusItem *aParent = 0)
+        : type(aType), parent(aParent), isPrefetched(type != QDBusModel::PathItem), name(aName)
+        {}
+    inline ~QDBusItem()
+    {
+        qDeleteAll(children);
+    }
+
+    QString path() const
+    {
+        Q_ASSERT(type == QDBusModel::PathItem);
+
+        QString s;
+        const QDBusItem *item = this;
+        while (item) {
+            s.prepend(item->name);
+            item = item->parent;
+        }
+        if (s.length() > 1)
+            s.chop(1); // remove tailing slash
+        return s;
+    }
+
+    QDBusModel::Type type;
+    QDBusItem *parent;
+    QVector<QDBusItem *> children;
+    bool isPrefetched;
+    QString name;
+    QString caption;
+};
+
+QDomDocument QDBusModel::introspect(const QString &path)
+{
+    QDomDocument doc;
+
+    QDBusInterface iface(service, path, QLatin1String("org.freedesktop.DBus.Introspectable"), c);
+    if (!iface.isValid()) {
+        QDBusError err(iface.lastError());
+        emit busError(QString::fromLatin1("Cannot introspect object %1 at %2:\n  %3 (%4)\n").arg(path).arg(
+                      service).arg(err.name()).arg(err.message()));
+        return doc;
+    }
+
+    QDBusReply<QString> xml = iface.call(QLatin1String("Introspect"));
+
+    if (!xml.isValid()) {
+        QDBusError err(xml.error());
+        if (err.isValid()) {
+            emit busError(QString::fromLatin1("Call to object %1 at %2:\n  %3 (%4) failed\n").arg(
+                        path).arg(service).arg(err.name()).arg(err.message()));
+        } else {
+            emit busError(QString::fromLatin1("Invalid XML received from object %1 at %2\n").arg(
+                    path).arg(service));
+        }
+        return doc;
+    }
+
+    doc.setContent(xml);
+    return doc;
+}
+
+void QDBusModel::addMethods(QDBusItem *parent, const QDomElement &iface)
+{
+    Q_ASSERT(parent);
+
+    QDomElement child = iface.firstChildElement();
+    while (!child.isNull()) {
+        QDBusItem *item = 0;
+        if (child.tagName() == QLatin1String("method")) {
+            item = new QDBusItem(QDBusModel::MethodItem,
+                    child.attribute(QLatin1String("name")), parent);
+            item->caption = QLatin1String("Method: ") + item->name;
+        } else if (child.tagName() == QLatin1String("signal")) {
+            item = new QDBusItem(QDBusModel::SignalItem,
+                    child.attribute(QLatin1String("name")), parent);
+            item->caption = QLatin1String("Signal: ") + item->name;
+        } else if (child.tagName() == QLatin1String("property")) {
+            item = new QDBusItem(QDBusModel::PropertyItem,
+                    child.attribute(QLatin1String("name")), parent);
+            item->caption = QLatin1String("Property: ") + item->name;
+        } else {
+            qDebug() << "addMethods: unknown tag:" << child.tagName();
+        }
+        if (item)
+            parent->children.append(item);
+
+        child = child.nextSiblingElement();
+    }
+}
+
+void QDBusModel::addPath(QDBusItem *parent)
+{
+    Q_ASSERT(parent);
+
+    QString path = parent->path();
+
+    QDomDocument doc = introspect(path);
+    QDomElement node = doc.documentElement();
+    QDomElement child = node.firstChildElement();
+    while (!child.isNull()) {
+        if (child.tagName() == QLatin1String("node")) {
+            QDBusItem *item = new QDBusItem(QDBusModel::PathItem,
+                        child.attribute(QLatin1String("name")) + QLatin1Char('/'), parent);
+            parent->children.append(item);
+
+            addMethods(item, child);
+        } else if (child.tagName() == QLatin1String("interface")) {
+            QDBusItem *item = new QDBusItem(QDBusModel::InterfaceItem,
+                        child.attribute(QLatin1String("name")), parent);
+            parent->children.append(item);
+
+            addMethods(item, child);
+        } else {
+            qDebug() << "addPath: Unknown tag name:" << child.tagName();
+        }
+        child = child.nextSiblingElement();
+    }
+
+    parent->isPrefetched = true;
+}
+
+QDBusModel::QDBusModel(const QString &aService, const QDBusConnection &connection)
+    : service(aService), c(connection), root(0)
+{
+    root = new QDBusItem(QDBusModel::PathItem, QLatin1String("/"));
+}
+
+QDBusModel::~QDBusModel()
+{
+    delete root;
+}
+
+QModelIndex QDBusModel::index(int row, int column, const QModelIndex &parent) const
+{
+    const QDBusItem *item = static_cast<QDBusItem *>(parent.internalPointer());
+    if (!item)
+        item = root;
+
+    if (column != 0 || row < 0 || row >= item->children.count())
+        return QModelIndex();
+
+    return createIndex(row, 0, item->children.at(row));
+}
+
+QModelIndex QDBusModel::parent(const QModelIndex &child) const
+{
+    QDBusItem *item = static_cast<QDBusItem *>(child.internalPointer());
+    if (!item || !item->parent || !item->parent->parent)
+        return QModelIndex();
+
+    return createIndex(item->parent->parent->children.indexOf(item->parent), 0, item->parent);
+}
+
+int QDBusModel::rowCount(const QModelIndex &parent) const
+{
+    QDBusItem *item = static_cast<QDBusItem *>(parent.internalPointer());
+    if (!item)
+        item = root;
+    if (!item->isPrefetched)
+        const_cast<QDBusModel *>(this)->addPath(item);
+
+    return item->children.count();
+}
+
+int QDBusModel::columnCount(const QModelIndex &) const
+{
+    return 1;
+}
+
+QVariant QDBusModel::data(const QModelIndex &index, int role) const
+{
+    const QDBusItem *item = static_cast<QDBusItem *>(index.internalPointer());
+    if (!item)
+        return QVariant();
+
+    if (role != Qt::DisplayRole)
+        return QVariant();
+
+    return item->caption.isEmpty() ? item->name : item->caption;
+}
+
+QVariant QDBusModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (role != Qt::DisplayRole || orientation == Qt::Vertical || section != 0)
+        return QVariant();
+
+    return QLatin1String("Methods");
+}
+
+QDBusModel::Type QDBusModel::itemType(const QModelIndex &index) const
+{
+    const QDBusItem *item = static_cast<QDBusItem *>(index.internalPointer());
+    return item ? item->type : PathItem;
+}
+
+void QDBusModel::refresh(const QModelIndex &aIndex)
+{
+    QModelIndex index = aIndex;
+    while (index.isValid() && static_cast<QDBusItem *>(index.internalPointer())->type != PathItem) {
+        index = index.parent();
+    }
+
+    QDBusItem *item = static_cast<QDBusItem *>(index.internalPointer());
+    if (!item)
+        item = root;
+
+    if (!item->children.isEmpty()) {
+        beginRemoveRows(index, 0, item->children.count() - 1);
+        qDeleteAll(item->children);
+        item->children.clear();
+        endRemoveRows();
+    }
+
+    addPath(item);
+    if (!item->children.isEmpty()) {
+        beginInsertRows(index, 0, item->children.count() - 1);
+        endInsertRows();
+    }
+}
+
+QString QDBusModel::dBusPath(const QModelIndex &aIndex) const
+{
+    QModelIndex index = aIndex;
+    while (index.isValid() && static_cast<QDBusItem *>(index.internalPointer())->type != PathItem) {
+        index = index.parent();
+    }
+
+    QDBusItem *item = static_cast<QDBusItem *>(index.internalPointer());
+    if (!item)
+        item = root;
+
+    return item->path();
+}
+
+QString QDBusModel::dBusInterface(const QModelIndex &index) const
+{
+    QDBusItem *item = static_cast<QDBusItem *>(index.internalPointer());
+    if (!item)
+        return QString();
+    if (item->type == InterfaceItem)
+        return item->name;
+    if (item->parent && item->parent->type == InterfaceItem)
+        return item->parent->name;
+    return QString();
+}
+
+QString QDBusModel::dBusMethodName(const QModelIndex &index) const
+{
+    QDBusItem *item = static_cast<QDBusItem *>(index.internalPointer());
+    return item ? item->name : QString();
+}
+
+QModelIndex QDBusModel::findObject(const QDBusObjectPath &objectPath)
+{
+    QStringList path = objectPath.path().split(QLatin1Char('/'), QString::SkipEmptyParts);
+
+    QDBusItem *item = root;
+    int childIdx = -1;
+    while (item && !path.isEmpty()) {
+        const QString branch = path.takeFirst() + QLatin1Char('/');
+        childIdx = -1;
+
+        // do a linear search over all the children
+        for (int i = 0; i < item->children.count(); ++i) {
+            QDBusItem *child = item->children.at(i);
+            if (child->type == PathItem && child->name == branch) {
+                item = child;
+                childIdx = i;
+
+                // prefetch the found branch
+                if (!item->isPrefetched)
+                    addPath(item);
+                break;
+            }
+        }
+
+        // branch not found - bail out
+        if (childIdx == -1)
+            return QModelIndex();
+    }
+
+    // found the right item
+    if (childIdx != -1 && item && path.isEmpty())
+        return createIndex(childIdx, 0, item);
+
+    return QModelIndex();
+}
+
diff --git a/tools/qdbus/qdbusviewer/qdbusmodel.h b/tools/qdbus/qdbusviewer/qdbusmodel.h
new file mode 100644
index 0000000..50f928e
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusmodel.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDBUSMODEL_H
+#define QDBUSMODEL_H
+
+#include <QtCore/qabstractitemmodel.h>
+#include <QtDBus/QtDBus>
+
+struct QDBusItem;
+
+QT_FORWARD_DECLARE_CLASS(QDomDocument);
+QT_FORWARD_DECLARE_CLASS(QDomElement);
+
+
+class QDBusModel: public QAbstractItemModel
+{
+    Q_OBJECT
+
+public:
+    enum Type { InterfaceItem, PathItem, MethodItem, SignalItem, PropertyItem };
+
+    QDBusModel(const QString &service, const QDBusConnection &connection);
+    ~QDBusModel();
+
+    QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const;
+    QModelIndex parent(const QModelIndex &child) const;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const;
+
+    Type itemType(const QModelIndex &index) const;
+    QString dBusPath(const QModelIndex &index) const;
+    QString dBusInterface(const QModelIndex &index) const;
+    QString dBusMethodName(const QModelIndex &index) const;
+
+    void refresh(const QModelIndex &index = QModelIndex());
+
+    QModelIndex findObject(const QDBusObjectPath &objectPath);
+
+Q_SIGNALS:
+    void busError(const QString &text);
+
+private:
+    QDomDocument introspect(const QString &path);
+    void addMethods(QDBusItem *parent, const QDomElement &iface);
+    void addPath(QDBusItem *parent);
+
+    QString service;
+    QDBusConnection c;
+    QDBusItem *root;
+};
+
+#endif
+
diff --git a/tools/qdbus/qdbusviewer/qdbusviewer.cpp b/tools/qdbus/qdbusviewer/qdbusviewer.cpp
new file mode 100644
index 0000000..e8ac3a6
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusviewer.cpp
@@ -0,0 +1,509 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdbusviewer.h"
+#include "qdbusmodel.h"
+#include "propertydialog.h"
+
+#include <QtXml/QtXml>
+#include <QtDBus/private/qdbusutil_p.h>
+
+class QDBusViewModel: public QDBusModel
+{
+public:
+    inline QDBusViewModel(const QString &service, const QDBusConnection &connection)
+        : QDBusModel(service, connection)
+    {}
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const
+    {
+        if (role == Qt::FontRole && itemType(index) == InterfaceItem) {
+            QFont f;
+            f.setItalic(true);
+            return f;
+        }
+        return QDBusModel::data(index, role);
+    }
+};
+
+QDBusViewer::QDBusViewer(const QDBusConnection &connection, QWidget *parent)  :
+    QWidget(parent),
+    c(connection),
+    objectPathRegExp(QLatin1String("\\[ObjectPath: (.*)\\]"))
+{
+    services = new QTreeWidget;
+    services->setRootIsDecorated(false);
+    services->setHeaderLabels(QStringList(QLatin1String("Services")));
+
+    tree = new QTreeView;
+    tree->setContextMenuPolicy(Qt::CustomContextMenu);
+
+    connect(tree, SIGNAL(activated(const QModelIndex&)), this, SLOT(activate(const QModelIndex&)));
+
+    refreshAction = new QAction(tr("&Refresh"), tree);
+    refreshAction->setData(42); // increase the amount of 42 used as magic number by one
+    refreshAction->setShortcut(QKeySequence::Refresh);
+    connect(refreshAction, SIGNAL(triggered()), this, SLOT(refreshChildren()));
+
+    QShortcut *refreshShortcut = new QShortcut(QKeySequence::Refresh, tree);
+    connect(refreshShortcut, SIGNAL(activated()), this, SLOT(refreshChildren()));
+
+    QVBoxLayout *topLayout = new QVBoxLayout(this);
+    log = new QTextBrowser;
+    connect(log, SIGNAL(anchorClicked(QUrl)), this, SLOT(anchorClicked(QUrl)));
+
+    QHBoxLayout *layout = new QHBoxLayout;
+    layout->addWidget(services, 1);
+    layout->addWidget(tree, 2);
+
+    topLayout->addLayout(layout);
+    topLayout->addWidget(log);
+
+    connect(services, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
+            this, SLOT(serviceChanged(QTreeWidgetItem*)));
+    connect(tree, SIGNAL(customContextMenuRequested(QPoint)),
+            this, SLOT(showContextMenu(QPoint)));
+
+    QMetaObject::invokeMethod(this, "refresh", Qt::QueuedConnection);
+
+    if (c.isConnected()) {
+        logMessage(QLatin1String("Connected to D-Bus."));
+        QDBusConnectionInterface *iface = c.interface();
+        connect(iface, SIGNAL(serviceRegistered(QString)),
+                this, SLOT(serviceRegistered(QString)));
+        connect(iface, SIGNAL(serviceUnregistered(QString)),
+                this, SLOT(serviceUnregistered(QString)));
+        connect(iface, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
+                this, SLOT(serviceOwnerChanged(QString,QString,QString)));
+    } else {
+        logError(QLatin1String("Cannot connect to D-Bus: ") + c.lastError().message());
+    }
+
+    objectPathRegExp.setMinimal(true);
+
+}
+
+void QDBusViewer::logMessage(const QString &msg)
+{
+    log->append(msg + QLatin1Char('\n'));
+}
+
+void QDBusViewer::logError(const QString &msg)
+{
+    log->append(QLatin1String("<font color=\"red\">Error: </font>") + Qt::escape(msg) + QLatin1String("<br>"));
+}
+
+void QDBusViewer::refresh()
+{
+    services->clear();
+
+    if (c.isConnected()) {
+        const QStringList serviceNames = c.interface()->registeredServiceNames();
+        foreach (QString service, serviceNames)
+            new QTreeWidgetItem(services, QStringList(service));
+    }
+}
+
+void QDBusViewer::activate(const QModelIndex &item)
+{
+    if (!item.isValid())
+        return;
+
+    const QDBusModel *model = static_cast<const QDBusModel *>(item.model());
+
+    BusSignature sig;
+    sig.mService = currentService;
+    sig.mPath = model->dBusPath(item);
+    sig.mInterface = model->dBusInterface(item);
+    sig.mName = model->dBusMethodName(item);
+
+    switch (model->itemType(item)) {
+    case QDBusModel::SignalItem:
+        connectionRequested(sig);
+        break;
+    case QDBusModel::MethodItem:
+        callMethod(sig);
+        break;
+    case QDBusModel::PropertyItem:
+        getProperty(sig);
+        break;
+    default:
+        break;
+    }
+}
+
+void QDBusViewer::getProperty(const BusSignature &sig)
+{
+    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Get"));
+    QList<QVariant> arguments;
+    arguments << sig.mInterface << sig.mName;
+    message.setArguments(arguments);
+    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
+}
+
+void QDBusViewer::setProperty(const BusSignature &sig)
+{
+    QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
+    QMetaProperty prop = iface.metaObject()->property(iface.metaObject()->indexOfProperty(sig.mName.toLatin1()));
+
+    bool ok;
+    QString input = QInputDialog::getText(this, tr("Arguments"),
+                    tr("Please enter the value of the property %1 (type %2)").arg(
+                        sig.mName, QString::fromLatin1(prop.typeName())),
+                    QLineEdit::Normal, QString(), &ok);
+    if (!ok)
+        return;
+
+    QVariant value = input;
+    if (!value.convert(prop.type())) {
+        QMessageBox::warning(this, tr("Unable to marshall"),
+                tr("Value conversion failed, unable to set property"));
+        return;
+    }
+
+    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, QLatin1String("org.freedesktop.DBus.Properties"), QLatin1String("Set"));
+    QList<QVariant> arguments;
+    arguments << sig.mInterface << sig.mName << qVariantFromValue(QDBusVariant(value));
+    message.setArguments(arguments);
+    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
+
+}
+
+void QDBusViewer::callMethod(const BusSignature &sig)
+{
+    QDBusInterface iface(sig.mService, sig.mPath, sig.mInterface, c);
+    const QMetaObject *mo = iface.metaObject();
+
+    // find the method
+    QMetaMethod method;
+    for (int i = 0; i < mo->methodCount(); ++i) {
+        const QString signature = QString::fromLatin1(mo->method(i).signature());
+        if (signature.startsWith(sig.mName) && signature.at(sig.mName.length()) == QLatin1Char('('))
+            method = mo->method(i);
+    }
+    if (!method.signature()) {
+        QMessageBox::warning(this, tr("Unable to find method"),
+                tr("Unable to find method %1 on path %2 in interface %3").arg(
+                    sig.mName).arg(sig.mPath).arg(sig.mInterface));
+        return;
+    }
+
+    PropertyDialog dialog;
+    QList<QVariant> args;
+
+    const QList<QByteArray> paramTypes = method.parameterTypes();
+    const QList<QByteArray> paramNames = method.parameterNames();
+    QList<int> types; // remember the low-level D-Bus type
+    for (int i = 0; i < paramTypes.count(); ++i) {
+        const QByteArray paramType = paramTypes.at(i);
+        if (paramType.endsWith('&'))
+            continue; // ignore OUT parameters
+
+        QVariant::Type type = QVariant::nameToType(paramType);
+        dialog.addProperty(QString::fromLatin1(paramNames.value(i)), type);
+        types.append(QMetaType::type(paramType));
+    }
+
+    if (!types.isEmpty()) {
+        dialog.setInfo(tr("Please enter parameters for the method \"%1\"").arg(sig.mName));
+
+        if (dialog.exec() != QDialog::Accepted)
+            return;
+
+        args = dialog.values();
+    }
+
+    // Special case - convert a value to a QDBusVariant if the
+    // interface wants a variant
+    for (int i = 0; i < args.count(); ++i) {
+        if (types.at(i) == qMetaTypeId<QDBusVariant>())
+            args[i] = qVariantFromValue(QDBusVariant(args.at(i)));
+    }
+
+    QDBusMessage message = QDBusMessage::createMethodCall(sig.mService, sig.mPath, sig.mInterface,
+            sig.mName);
+    message.setArguments(args);
+    c.callWithCallback(message, this, SLOT(dumpMessage(QDBusMessage)));
+}
+
+void QDBusViewer::showContextMenu(const QPoint &point)
+{
+    QModelIndex item = tree->indexAt(point);
+    if (!item.isValid())
+        return;
+
+    const QDBusModel *model = static_cast<const QDBusModel *>(item.model());
+
+    BusSignature sig;
+    sig.mService = currentService;
+    sig.mPath = model->dBusPath(item);
+    sig.mInterface = model->dBusInterface(item);
+    sig.mName = model->dBusMethodName(item);
+
+    QMenu menu;
+    menu.addAction(refreshAction);
+
+    switch (model->itemType(item)) {
+    case QDBusModel::SignalItem: {
+        QAction *action = new QAction(tr("&Connect"), &menu);
+        action->setData(1);
+        menu.addAction(action);
+        break; }
+    case QDBusModel::MethodItem: {
+        QAction *action = new QAction(tr("&Call"), &menu);
+        action->setData(2);
+        menu.addAction(action);
+        break; }
+    case QDBusModel::PropertyItem: {
+        QAction *actionSet = new QAction(tr("&Set value"), &menu);
+        actionSet->setData(3);
+        QAction *actionGet = new QAction(tr("&Get value"), &menu);
+        actionGet->setData(4);
+        menu.addAction(actionSet);
+        menu.addAction(actionGet);
+        break; }
+    default:
+        break;
+    }
+
+    QAction *selectedAction = menu.exec(tree->viewport()->mapToGlobal(point));
+    if (!selectedAction)
+        return;
+
+    switch (selectedAction->data().toInt()) {
+    case 1:
+        connectionRequested(sig);
+        break;
+    case 2:
+        callMethod(sig);
+        break;
+    case 3:
+        setProperty(sig);
+        break;
+    case 4:
+        getProperty(sig);
+        break;
+    }
+}
+
+void QDBusViewer::connectionRequested(const BusSignature &sig)
+{
+    if (!c.connect(sig.mService, QString(), sig.mInterface, sig.mName, this,
+              SLOT(dumpMessage(QDBusMessage)))) {
+        logError(tr("Unable to connect to service %1, path %2, interface %3, signal %4").arg(
+                    sig.mService).arg(sig.mPath).arg(sig.mInterface).arg(sig.mName));
+    }
+}
+
+void QDBusViewer::dumpMessage(const QDBusMessage &message)
+{
+    QList<QVariant> args = message.arguments();
+    QString out = QLatin1String("Received ");
+
+    switch (message.type()) {
+    case QDBusMessage::SignalMessage:
+        out += QLatin1String("signal ");
+        break;
+    case QDBusMessage::ErrorMessage:
+        out += QLatin1String("error message ");
+        break;
+    case QDBusMessage::ReplyMessage:
+        out += QLatin1String("reply ");
+        break;
+    default:
+        out += QLatin1String("message ");
+        break;
+    }
+
+    out += QLatin1String("from ");
+    out += message.service();
+    if (!message.path().isEmpty())
+        out += QLatin1String(", path ") + message.path();
+    if (!message.interface().isEmpty())
+        out += QLatin1String(", interface <i>") + message.interface() + QLatin1String("</i>");
+    if (!message.member().isEmpty())
+        out += QLatin1String(", member ") + message.member();
+    out += QLatin1String("<br>");
+    if (args.isEmpty()) {
+        out += QLatin1String("&nbsp;&nbsp;(no arguments)");
+    } else {
+        out += QLatin1String("&nbsp;&nbsp;Arguments: ");
+        foreach (QVariant arg, args) {
+            QString str = Qt::escape(QDBusUtil::argumentToString(arg));
+            // turn object paths into clickable links
+            str.replace(objectPathRegExp, QLatin1String("[ObjectPath: <a href=\"qdbus://bus\\1\">\\1</a>]"));
+            out += str;
+            out += QLatin1String(", ");
+        }
+        out.chop(2);
+    }
+
+    log->append(out);
+}
+
+void QDBusViewer::serviceChanged(QTreeWidgetItem *item)
+{
+    delete tree->model();
+
+    currentService.clear();
+    if (!item)
+        return;
+    currentService = item->text(0);
+
+    tree->setModel(new QDBusViewModel(currentService, c));
+    connect(tree->model(), SIGNAL(busError(QString)), this, SLOT(logError(QString)));
+}
+
+void QDBusViewer::serviceRegistered(const QString &service)
+{
+    if (service == c.baseService())
+        return;
+
+    new QTreeWidgetItem(services, QStringList(service));
+}
+
+static QTreeWidgetItem *findItem(const QTreeWidget *services, const QString &name)
+{
+    for (int i = 0; i < services->topLevelItemCount(); ++i) {
+        if (services->topLevelItem(i)->text(0) == name)
+            return services->topLevelItem(i);
+    }
+    return 0;
+}
+
+void QDBusViewer::serviceUnregistered(const QString &name)
+{
+    delete findItem(services, name);
+}
+
+void QDBusViewer::serviceOwnerChanged(const QString &name, const QString &oldOwner,
+                                      const QString &newOwner)
+{
+    QTreeWidgetItem *item = findItem(services, name);
+
+    if (!item && oldOwner.isEmpty() && !newOwner.isEmpty())
+        serviceRegistered(name);
+    else if (item && !oldOwner.isEmpty() && newOwner.isEmpty())
+        delete item;
+    else if (item && !oldOwner.isEmpty() && !newOwner.isEmpty()) {
+        delete item;
+        serviceRegistered(name);
+    }
+}
+
+void QDBusViewer::refreshChildren()
+{
+    QDBusModel *model = qobject_cast<QDBusModel *>(tree->model());
+    if (!model)
+        return;
+    model->refresh(tree->currentIndex());
+}
+
+void QDBusViewer::about()
+{
+    QMessageBox box(this);
+#if QT_EDITION == QT_EDITION_OPENSOURCE
+    QString edition = tr("Open Source Edition");
+    QString info = tr("This version of Qt's D-Bus Viewer is part of the Qt Open Source Edition. "
+            "Qt is a comprehensive C++ framework for cross-platform application "
+            "development.");
+    QString moreInfo = tr("You need a commercial Qt license for development of proprietary (closed "
+            "source) applications. Please see <a href=\"http://qtsoftware.com/company/model"
+            ".html\">qtsoftware.com/company/model.html</a> for an overview of Qt licensing.");
+#else
+    QString edition;
+    QString info;
+    QString moreInfo(tr("This program is licensed to you under the terms of the "
+                "Qt Commercial License Agreement. For details, see the file LICENSE "
+                "that came with this software distribution."));
+
+#endif
+
+    box.setText(QString::fromLatin1("<center><img src=\":/trolltech/qdbusviewer/images/qdbusviewer-128.png\">"
+                "<h3>%1</h3>"
+                "<p>Version %2 %3</p></center>"
+                "<p>%4</p>"
+                "<p>%5</p>"
+                "<p>Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).</p>"
+                "<p>The program is provided AS IS with NO WARRANTY OF ANY KIND,"
+                " INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A"
+                " PARTICULAR PURPOSE.<p/>")
+            .arg(tr("D-Bus Viewer")).arg(QLatin1String(QT_VERSION_STR)).arg(edition).arg(info).arg(moreInfo));
+    box.setWindowTitle(tr("D-Bus Viewer"));
+    box.exec();
+}
+
+void QDBusViewer::anchorClicked(const QUrl &url)
+{
+    if (url.scheme() != QLatin1String("qdbus"))
+        // not ours
+        return;
+
+    // swallow the click without setting a new document
+    log->setSource(QUrl());
+
+    QDBusModel *model = qobject_cast<QDBusModel *>(tree->model());
+    if (!model)
+        return;
+
+    QModelIndex idx = model->findObject(QDBusObjectPath(url.path()));
+    if (!idx.isValid())
+        return;
+
+    tree->scrollTo(idx);
+    tree->setCurrentIndex(idx);
+}
+
+/*!
+  \page qdbusviewer.html
+  \title D-Bus Viewer
+  \keyword qdbusviewer
+
+  The Qt D-Bus Viewer is a tool that lets you introspect D-Bus objects and messages. You can
+  choose between the system bus and the session bus. Click on any service on the list
+  on the left side to see all the exported objects.
+
+  You can invoke methods by double-clicking on them. If a method takes one or more IN parameters,
+  a property editor opens.
+
+  Right-click on a signal to connect to it. All emitted signals including their parameters
+  are output in the message view on the lower side of the window.
+*/
diff --git a/tools/qdbus/qdbusviewer/qdbusviewer.h b/tools/qdbus/qdbusviewer/qdbusviewer.h
new file mode 100644
index 0000000..75511b7
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusviewer.h
@@ -0,0 +1,98 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDBUSVIEWER_H
+#define QDBUSVIEWER_H
+
+#include <QtGui/QtGui>
+#include <QtDBus/QtDBus>
+
+QT_FORWARD_DECLARE_CLASS(QTreeView);
+QT_FORWARD_DECLARE_CLASS(QDomDocument);
+QT_FORWARD_DECLARE_CLASS(QDomElement);
+
+struct BusSignature
+{
+    QString mService, mPath, mInterface, mName;
+};
+
+class QDBusViewer: public QWidget
+{
+    Q_OBJECT
+public:
+    QDBusViewer(const QDBusConnection &connection, QWidget *parent = 0);
+
+public slots:
+    void refresh();
+    void about();
+
+private slots:
+    void serviceChanged(QTreeWidgetItem *item);
+    void showContextMenu(const QPoint &);
+    void connectionRequested(const BusSignature &sig);
+    void callMethod(const BusSignature &sig);
+    void getProperty(const BusSignature &sig);
+    void setProperty(const BusSignature &sig);
+    void dumpMessage(const QDBusMessage &msg);
+    void refreshChildren();
+
+    void serviceRegistered(const QString &service);
+    void serviceUnregistered(const QString &service);
+    void serviceOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner);
+
+    void activate(const QModelIndex &item);
+
+    void logError(const QString &msg);
+    void anchorClicked(const QUrl &url);
+
+private:
+    void logMessage(const QString &msg);
+
+    QDBusConnection c;
+    QString currentService;
+    QTreeView *tree;
+    QAction *refreshAction;
+    QTreeWidget *services;
+    QTextBrowser *log;
+    QRegExp objectPathRegExp;
+};
+
+#endif
diff --git a/tools/qdbus/qdbusviewer/qdbusviewer.pro b/tools/qdbus/qdbusviewer/qdbusviewer.pro
new file mode 100644
index 0000000..6727691
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusviewer.pro
@@ -0,0 +1,30 @@
+TEMPLATE        = app
+TARGET          = qdbusviewer
+
+HEADERS         = qdbusviewer.h \
+                  qdbusmodel.h \
+                  propertydialog.h
+
+SOURCES         = qdbusviewer.cpp \
+                  qdbusmodel.cpp \
+                  propertydialog.cpp \
+                  main.cpp
+
+RESOURCES += qdbusviewer.qrc
+
+DESTDIR = ../../../bin
+
+CONFIG += qdbus
+QT += xml
+
+target.path=$$[QT_INSTALL_BINS]
+INSTALLS += target
+
+mac {
+    ICON = images/qdbusviewer.icns
+    QMAKE_INFO_PLIST = Info_mac.plist
+}
+
+win32 {
+    RC_FILE = qdbusviewer.rc
+}
diff --git a/tools/qdbus/qdbusviewer/qdbusviewer.qrc b/tools/qdbus/qdbusviewer/qdbusviewer.qrc
new file mode 100644
index 0000000..7d592f3
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusviewer.qrc
@@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/trolltech/qdbusviewer" >
+        <file>images/qdbusviewer-128.png</file>
+        <file>images/qdbusviewer.png</file>
+    </qresource>
+</RCC>
diff --git a/tools/qdbus/qdbusviewer/qdbusviewer.rc b/tools/qdbus/qdbusviewer/qdbusviewer.rc
new file mode 100644
index 0000000..c4b1d60
--- /dev/null
+++ b/tools/qdbus/qdbusviewer/qdbusviewer.rc
@@ -0,0 +1 @@
+IDI_ICON1		ICON		DISCARDABLE	"images/qdbusviewer.ico"
diff --git a/tools/qdbus/qdbusxml2cpp/qdbusxml2cpp.cpp b/tools/qdbus/qdbusxml2cpp/qdbusxml2cpp.cpp
new file mode 100644
index 0000000..a871fe4
--- /dev/null
+++ b/tools/qdbus/qdbusxml2cpp/qdbusxml2cpp.cpp
@@ -0,0 +1,1150 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the tools applications of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain
+** additional rights. These rights are described in the Nokia Qt LGPL
+** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qfile.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qstringlist.h>
+#include <QtCore/qtextstream.h>
+#include <QtCore/qset.h>
+
+#include <QtDBus/QtDBus>
+#include "private/qdbusmetaobject_p.h"
+#include "private/qdbusintrospection_p.h"
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef Q_WS_WIN
+#include <process.h>
+#endif
+
+#define PROGRAMNAME     "qdbusxml2cpp"
+#define PROGRAMVERSION  "0.7"
+#define PROGRAMCOPYRIGHT "Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)."
+
+#define ANNOTATION_NO_WAIT      "org.freedesktop.DBus.Method.NoReply"
+
+static QString globalClassName;
+static QString parentClassName;
+static QString proxyFile;
+static QString adaptorFile;
+static QString inputFile;
+static bool skipNamespaces;
+static bool verbose;
+static bool includeMocs;
+static QString commandLine;
+static QStringList includes;
+static QStringList wantedInterfaces;
+
+static const char help[] =
+    "Usage: " PROGRAMNAME " [options...] [xml-or-xml-file] [interfaces...]\n"
+    "Produces the C++ code to implement the interfaces defined in the input file.\n"
+    "If no options are given, the code is written to the standard output.\n"
+    "\n"
+    "Options:\n"
+    "  -a <filename>    Write the adaptor code to <filename>\n"
+    "  -c <classname>   Use <classname> as the class name for the generated classes\n"
+    "  -h               Show this information\n"
+    "  -i <filename>    Add #include to the output\n"
+    "  -l <classname>   When generating an adaptor, use <classname> as the parent class\n"
+    "  -m               Generate #include \"filename.moc\" statements in the .cpp files\n"
+    "  -N               Don't use namespaces\n"
+    "  -p <filename>    Write the proxy code to <filename>\n"
+    "  -v               Be verbose.\n"
+    "  -V               Show the program version and quit.\n"
+    "\n"
+    "If the file name given to the options -a and -p does not end in .cpp or .h, the\n"
+    "program will automatically append the suffixes and produce both files.\n"
+    "You can also use a colon (:) to separate the header name from the source file\n"
+    "name, as in '-a filename_p.h:filename.cpp'.\n";
+
+static const char includeList[] =
+    "#include <QtCore/QByteArray>\n"
+    "#include <QtCore/QList>\n"
+    "#include <QtCore/QMap>\n"
+    "#include <QtCore/QString>\n"
+    "#include <QtCore/QStringList>\n"
+    "#include <QtCore/QVariant>\n";
+
+static const char forwardDeclarations[] =
+    "class QByteArray;\n"
+    "template<class T> class QList;\n"
+    "template<class Key, class Value> class QMap;\n"
+    "class QString;\n"
+    "class QStringList;\n"
+    "class QVariant;\n";
+
+static void showHelp()
+{
+    printf("%s", help);
+    exit(0);
+}
+
+static void showVersion()
+{
+    printf("%s version %s\n", PROGRAMNAME, PROGRAMVERSION);
+    printf("D-Bus binding tool for Qt\n");
+    exit(0);
+}
+
+static QString nextArg(QStringList &args, int i, char opt)
+{
+    QString arg = args.value(i);
+    if (arg.isEmpty()) {
+        printf("-%c needs at least one argument\n", opt);
+        exit(1);
+    }
+    return args.takeAt(i);
+}
+
+static void parseCmdLine(QStringList args)
+{
+    args.takeFirst();
+
+    commandLine = QLatin1String(PROGRAMNAME " ");
+    commandLine += args.join(QLatin1String(" "));
+
+    int i = 0;
+    while (i < args.count()) {
+
+        if (!args.at(i).startsWith(QLatin1Char('-'))) {
+            ++i;
+            continue;
+        }
+        QString arg = args.takeAt(i);
+
+        char c = '\0';
+        if (arg.length() == 2)
+            c = arg.at(1).toLatin1();
+        else if (arg == QLatin1String("--help"))
+            c = 'h';
+
+        switch (c) {
+        case 'a':
+            adaptorFile = nextArg(args, i, 'a');
+            break;
+
+        case 'c':
+            globalClassName = nextArg(args, i, 'c');
+            break;
+
+        case 'v':
+            verbose = true;
+            break;
+
+        case 'i':
+            includes << nextArg(args, i, 'i');
+            break;
+
+        case 'l':
+            parentClassName = nextArg(args, i, 'l');
+            break;
+
+        case 'm':
+            includeMocs = true;
+            break;
+
+        case 'N':
+            skipNamespaces = true;
+            break;
+
+        case '?':
+        case 'h':
+            showHelp();
+            break;
+
+        case 'V':
+            showVersion();
+            break;
+
+        case 'p':
+            proxyFile = nextArg(args, i, 'p');
+            break;
+
+        default:
+            printf("unknown option: '%s'\n", qPrintable(arg));
+            exit(1);
+        }
+    }
+
+    if (!args.isEmpty())
+        inputFile = args.takeFirst();
+
+    wantedInterfaces << args;
+}
+
+static QDBusIntrospection::Interfaces readInput()
+{
+    QFile input(inputFile);
+    if (inputFile.isEmpty() || inputFile == QLatin1String("-"))
+        input.open(stdin, QIODevice::ReadOnly);
+    else
+        input.open(QIODevice::ReadOnly);
+
+    QByteArray data = input.readAll();
+
+    // check if the input is already XML
+    data = data.trimmed();
+    if (data.startsWith("<!DOCTYPE ") || data.startsWith("<?xml") ||
+        data.startsWith("<node") || data.startsWith("<interface"))
+        // already XML
+        return QDBusIntrospection::parseInterfaces(QString::fromUtf8(data));
+
+    fprintf(stderr, "Cannot process input: '%s'. Stop.\n", qPrintable(inputFile));
+    exit(1);
+}
+
+static void cleanInterfaces(QDBusIntrospection::Interfaces &interfaces)
+{
+    if (!wantedInterfaces.isEmpty()) {
+        QDBusIntrospection::Interfaces::Iterator it = interfaces.begin();
+        while (it != interfaces.end())
+            if (!wantedInterfaces.contains(it.key()))
+                it = interfaces.erase(it);
+            else
+                ++it;
+    }
+}
+
+// produce a header name from the file name
+static QString header(const QString &name)
+{
+    QStringList parts = name.split(QLatin1Char(':'));
+    QString retval = parts.first();
+
+    if (retval.isEmpty() || retval == QLatin1String("-"))
+        return retval;
+
+    if (!retval.endsWith(QLatin1String(".h")) && !retval.endsWith(QLatin1String(".cpp")) &&
+        !retval.endsWith(QLatin1String(".cc")))
+        retval.append(QLatin1String(".h"));
+
+    return retval;
+}
+
+// produce a cpp name from the file name
+static QString cpp(const QString &name)
+{
+    QStringList parts = name.split(QLatin1Char(':'));
+    QString retval = parts.last();
+
+    if (retval.isEmpty() || retval == QLatin1String("-"))
+        return retval;
+
+    if (!retval.endsWith(QLatin1String(".h")) && !retval.endsWith(QLatin1String(".cpp")) &&
+        !retval.endsWith(QLatin1String(".cc")))
+        retval.append(QLatin1String(".cpp"));
+
+    return retval;
+}
+
+// produce a moc name from the file name
+static QString moc(const QString &name)
+{
+    QString retval = header(name);
+    if (retval.isEmpty())
+        return retval;
+
+    retval.truncate(retval.length() - 1); // drop the h in .h
+    retval += QLatin1String("moc");
+    return retval;
+}
+
+static QTextStream &writeHeader(QTextStream &ts, bool changesWillBeLost)
+{
+    ts << "/*" << endl
+       << " * This file was generated by " PROGRAMNAME " version " PROGRAMVERSION << endl
+       << " * Command line was: " << commandLine << endl
+       << " *" << endl
+       << " * " PROGRAMNAME " is " PROGRAMCOPYRIGHT << endl
+       << " *" << endl
+       << " * This is an auto-generated file." << endl;
+
+    if (changesWillBeLost)
+        ts << " * Do not edit! All changes made to it will be lost." << endl;
+    else
+        ts << " * This file may have been hand-edited. Look for HAND-EDIT comments" << endl
+           << " * before re-generating it." << endl;
+
+    ts << " */" << endl
+       << endl;
+
+    return ts;
+}
+
+enum ClassType { Proxy, Adaptor };
+static QString classNameForInterface(const QString &interface, ClassType classType)
+{
+    if (!globalClassName.isEmpty())
+        return globalClassName;
+
+    QStringList parts = interface.split(QLatin1Char('.'));
+
+    QString retval;
+    if (classType == Proxy)
+        foreach (QString part, parts) {
+            part[0] = part[0].toUpper();
+            retval += part;
+        }
+    else {
+        retval = parts.last();
+        retval[0] = retval[0].toUpper();
+    }
+
+    if (classType == Proxy)
+        retval += QLatin1String("Interface");
+    else
+        retval += QLatin1String("Adaptor");
+
+    return retval;
+}
+
+static QByteArray qtTypeName(const QString &signature, const QDBusIntrospection::Annotations &annotations, int paramId = -1, const char *direction = "Out")
+{
+    int type = QDBusMetaType::signatureToType(signature.toLatin1());
+    if (type == QVariant::Invalid) {
+        QString annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");
+        if (paramId >= 0)
+            annotationName += QString::fromLatin1(".%1%2").arg(QLatin1String(direction)).arg(paramId);
+        QString qttype = annotations.value(annotationName);
+        if (!qttype.isEmpty())
+            return qttype.toLatin1();
+
+        fprintf(stderr, "Got unknown type `%s'\n", qPrintable(signature));
+        fprintf(stderr, "You should add <annotation name=\"%s\" value=\"<type>\"/> to the XML description\n",
+                qPrintable(annotationName));
+        exit(1);
+    }
+
+    return QVariant::typeToName(QVariant::Type(type));
+}
+
+static QString nonConstRefArg(const QByteArray &arg)
+{
+    return QLatin1String(arg + " &");
+}
+
+static QString templateArg(const QByteArray &arg)
+{
+    if (!arg.endsWith('>'))
+        return QLatin1String(arg);
+
+    return QLatin1String(arg + ' ');
+}
+
+static QString constRefArg(const QByteArray &arg)
+{
+    if (!arg.startsWith('Q'))
+        return QLatin1String(arg + ' ');
+    else
+        return QString( QLatin1String("const %1 &") ).arg( QLatin1String(arg) );
+}
+
+static QStringList makeArgNames(const QDBusIntrospection::Arguments &inputArgs,
+                                const QDBusIntrospection::Arguments &outputArgs =
+                                QDBusIntrospection::Arguments())
+{
+    QStringList retval;
+    for (int i = 0; i < inputArgs.count(); ++i) {
+        const QDBusIntrospection::Argument &arg = inputArgs.at(i);
+        QString name = arg.name;
+        if (name.isEmpty())
+            name = QString( QLatin1String("in%1") ).arg(i);
+        while (retval.contains(name))
+            name += QLatin1String("_");
+        retval << name;
+    }
+    for (int i = 0; i < outputArgs.count(); ++i) {
+        const QDBusIntrospection::Argument &arg = outputArgs.at(i);
+        QString name = arg.name;
+        if (name.isEmpty())
+            name = QString( QLatin1String("out%1") ).arg(i);
+        while (retval.contains(name))
+            name += QLatin1String("_");
+        retval << name;
+    }
+    return retval;
+}
+
+static void writeArgList(QTextStream &ts, const QStringList &argNames,
+                         const QDBusIntrospection::Annotations &annotations,
+                         const QDBusIntrospection::Arguments &inputArgs,
+                         const QDBusIntrospection::Arguments &outputArgs = QDBusIntrospection::Arguments())
+{
+    // input args:
+    bool first = true;
+    int argPos = 0;
+    for (int i = 0; i < inputArgs.count(); ++i) {
+        const QDBusIntrospection::Argument &arg = inputArgs.at(i);
+        QString type = constRefArg(qtTypeName(arg.type, annotations, i, "In"));
+
+        if (!first)
+            ts << ", ";
+        ts << type << argNames.at(argPos++);
+        first = false;
+    }
+
+    argPos++;
+
+    // output args
+    // yes, starting from 1
+    for (int i = 1; i < outputArgs.count(); ++i) {
+        const QDBusIntrospection::Argument &arg = outputArgs.at(i);
+        QString name = arg.name;
+
+        if (!first)
+            ts << ", ";
+        ts << nonConstRefArg(qtTypeName(arg.type, annotations, i, "Out"))
+           << argNames.at(argPos++);
+        first = false;
+    }
+}
+
+static QString propertyGetter(const QDBusIntrospection::Property &property)
+{
+    QString getter = property.annotations.value(QLatin1String("com.trolltech.QtDBus.propertyGetter"));
+    if (getter.isEmpty()) {
+        getter =  property.name;
+        getter[0] = getter[0].toLower();
+    }
+    return getter;
+}
+
+static QString propertySetter(const QDBusIntrospection::Property &property)
+{
+    QString setter = property.annotations.value(QLatin1String("com.trolltech.QtDBus.propertySetter"));
+    if (setter.isEmpty()) {
+        setter = QLatin1String("set") + property.name;
+        setter[3] = setter[3].toUpper();
+    }
+    return setter;
+}
+
+static QString stringify(const QString &data)
+{
+    QString retval;
+    int i;
+    for (i = 0; i < data.length(); ++i) {
+        retval += QLatin1Char('\"');
+        for ( ; i < data.length() && data[i] != QLatin1Char('\n'); ++i)
+            if (data[i] == QLatin1Char('\"'))
+                retval += QLatin1String("\\\"");
+            else
+                retval += data[i];
+        retval += QLatin1String("\\n\"\n");
+    }
+    return retval;
+}
+
+static void openFile(const QString &fileName, QFile &file)
+{
+    if (fileName.isEmpty())
+        return;
+
+    bool isOk = false;
+    if (fileName == QLatin1String("-")) {
+        isOk = file.open(stdout, QIODevice::WriteOnly | QIODevice::Text);
+    } else {
+        file.setFileName(fileName);
+        isOk = file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Text);
+    }
+
+    if (!isOk)
+        fprintf(stderr, "Unable to open '%s': %s\n", qPrintable(fileName),
+                qPrintable(file.errorString()));
+}
+
+static void writeProxy(const QString &filename, const QDBusIntrospection::Interfaces &interfaces)
+{
+    // open the file
+    QString headerName = header(filename);
+    QByteArray headerData;
+    QTextStream hs(&headerData);
+
+    QString cppName = cpp(filename);
+    QByteArray cppData;
+    QTextStream cs(&cppData);
+
+    // write the header:
+    writeHeader(hs, true);
+    if (cppName != headerName)
+        writeHeader(cs, false);
+
+    // include guards:
+    QString includeGuard;
+    if (!headerName.isEmpty() && headerName != QLatin1String("-")) {
+        includeGuard = headerName.toUpper().replace(QLatin1Char('.'), QLatin1Char('_'));
+        int pos = includeGuard.lastIndexOf(QLatin1Char('/'));
+        if (pos != -1)
+            includeGuard = includeGuard.mid(pos + 1);
+    } else {
+        includeGuard = QLatin1String("QDBUSXML2CPP_PROXY");
+    }
+    includeGuard = QString(QLatin1String("%1_%2"))
+                   .arg(includeGuard)
+                   .arg(QDateTime::currentDateTime().toTime_t());
+    hs << "#ifndef " << includeGuard << endl
+       << "#define " << includeGuard << endl
+       << endl;
+
+    // include our stuff:
+    hs << "#include <QtCore/QObject>" << endl
+       << includeList
+       << "#include <QtDBus/QtDBus>" << endl;
+
+    foreach (QString include, includes) {
+        hs << "#include \"" << include << "\"" << endl;
+        if (headerName.isEmpty())
+            cs << "#include \"" << include << "\"" << endl;
+    }
+
+    hs << endl;
+
+    if (cppName != headerName) {
+        if (!headerName.isEmpty() && headerName != QLatin1String("-"))
+            cs << "#include \"" << headerName << "\"" << endl << endl;
+    }
+
+    foreach (const QDBusIntrospection::Interface *interface, interfaces) {
+        QString className = classNameForInterface(interface->name, Proxy);
+
+        // comment:
+        hs << "/*" << endl
+           << " * Proxy class for interface " << interface->name << endl
+           << " */" << endl;
+        cs << "/*" << endl
+           << " * Implementation of interface class " << className << endl
+           << " */" << endl
+           << endl;
+
+        // class header:
+        hs << "class " << className << ": public QDBusAbstractInterface" << endl
+           << "{" << endl
+           << "    Q_OBJECT" << endl;
+
+        // the interface name
+        hs << "public:" << endl
+           << "    static inline const char *staticInterfaceName()" << endl
+           << "    { return \"" << interface->name << "\"; }" << endl
+           << endl;
+
+        // constructors/destructors:
+        hs << "public:" << endl
+           << "    " << className << "(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);" << endl
+           << endl
+           << "    ~" << className << "();" << endl
+           << endl;
+        cs << className << "::" << className << "(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)" << endl
+           << "    : QDBusAbstractInterface(service, path, staticInterfaceName(), connection, parent)" << endl
+           << "{" << endl
+           << "}" << endl
+           << endl
+           << className << "::~" << className << "()" << endl
+           << "{" << endl
+           << "}" << endl
+           << endl;
+
+        // properties:
+        foreach (const QDBusIntrospection::Property &property, interface->properties) {
+            QByteArray type = qtTypeName(property.type, property.annotations);
+            QString templateType = templateArg(type);
+            QString constRefType = constRefArg(type);
+            QString getter = propertyGetter(property);
+            QString setter = propertySetter(property);
+
+            hs << "    Q_PROPERTY(" << type << " " << property.name;
+
+            // getter:
+            if (property.access != QDBusIntrospection::Property::Write)
+                // it's readble
+                hs << " READ " << getter;
+
+            // setter
+            if (property.access != QDBusIntrospection::Property::Read)
+                // it's writeable
+                hs << " WRITE " << setter;
+
+            hs << ")" << endl;
+
+            // getter:
+            if (property.access != QDBusIntrospection::Property::Write) {
+                hs << "    inline " << type << " " << getter << "() const" << endl;
+                if (type != "QVariant")
+                    hs << "    { return qvariant_cast< " << type << " >(internalPropGet(\""
+                       << property.name << "\")); }" << endl;
+                else
+                    hs << "    { return internalPropGet(\"" << property.name << "\"); }" << endl;
+            }
+
+            // setter:
+            if (property.access != QDBusIntrospection::Property::Read) {
+                hs << "    inline void " << setter << "(" << constRefArg(type) << "value)" << endl
+                   << "    { internalPropSet(\"" << property.name
+                   << "\", qVariantFromValue(value)); }" << endl;
+            }
+
+            hs << endl;
+        }
+
+        // methods:
+        hs << "public Q_SLOTS: // METHODS" << endl;
+        foreach (const QDBusIntrospection::Method &method, interface->methods) {
+            bool isDeprecated = method.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) == QLatin1String("true");
+            bool isNoReply =
+                method.annotations.value(QLatin1String(ANNOTATION_NO_WAIT)) == QLatin1String("true");
+            if (isNoReply && !method.outputArgs.isEmpty()) {
+                fprintf(stderr, "warning: method %s in interface %s is marked 'no-reply' but has output arguments.\n",
+                        qPrintable(method.name), qPrintable(interface->name));
+                continue;
+            }
+
+            hs << "    inline "
+               << (isDeprecated ? "Q_DECL_DEPRECATED " : "");
+
+            if (isNoReply) {
+                hs << "Q_NOREPLY void ";
+            } else {
+                hs << "QDBusPendingReply<";
+                for (int i = 0; i < method.outputArgs.count(); ++i)
+                    hs << (i > 0 ? ", " : "")
+                       << templateArg(qtTypeName(method.outputArgs.at(i).type, method.annotations, i, "Out"));
+                hs << "> ";
+            }
+
+            hs << method.name << "(";
+
+            QStringList argNames = makeArgNames(method.inputArgs);
+            writeArgList(hs, argNames, method.annotations, method.inputArgs);
+
+            hs << ")" << endl
+               << "    {" << endl
+               << "        QList<QVariant> argumentList;" << endl;
+
+            if (!method.inputArgs.isEmpty()) {
+                hs << "        argumentList";
+                for (int argPos = 0; argPos < method.inputArgs.count(); ++argPos)
+                    hs << " << qVariantFromValue(" << argNames.at(argPos) << ')';
+                hs << ";" << endl;
+            }
+
+            if (isNoReply)
+                hs << "        callWithArgumentList(QDBus::NoBlock, "
+                   <<  "QLatin1String(\"" << method.name << "\"), argumentList);" << endl;
+            else
+                hs << "        return asyncCallWithArgumentList(QLatin1String(\""
+                   << method.name << "\"), argumentList);" << endl;
+
+            // close the function:
+            hs << "    }" << endl;
+
+            if (method.outputArgs.count() > 1) {
+                // generate the old-form QDBusReply methods with multiple incoming parameters
+                hs << "    inline "
+                   << (isDeprecated ? "Q_DECL_DEPRECATED " : "")
+                   << "QDBusReply<"
+                   << templateArg(qtTypeName(method.outputArgs.first().type, method.annotations, 0, "Out")) << "> ";
+                hs << method.name << "(";
+
+                QStringList argNames = makeArgNames(method.inputArgs, method.outputArgs);
+                writeArgList(hs, argNames, method.annotations, method.inputArgs, method.outputArgs);
+
+                hs << ")" << endl
+                   << "    {" << endl
+                   << "        QList<QVariant> argumentList;" << endl;
+
+                int argPos = 0;
+                if (!method.inputArgs.isEmpty()) {
+                    hs << "        argumentList";
+                    for (argPos = 0; argPos < method.inputArgs.count(); ++argPos)
+                        hs << " << qVariantFromValue(" << argNames.at(argPos) << ')';
+                    hs << ";" << endl;
+                }
+
+                hs << "        QDBusMessage reply = callWithArgumentList(QDBus::Block, "
+                   <<  "QLatin1String(\"" << method.name << "\"), argumentList);" << endl;
+
+                argPos++;
+                hs << "        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == "
+                   << method.outputArgs.count() << ") {" << endl;
+
+                // yes, starting from 1
+                for (int i = 1; i < method.outputArgs.count(); ++i)
+                    hs << "            " << argNames.at(argPos++) << " = qdbus_cast<"
+                       << templateArg(qtTypeName(method.outputArgs.at(i).type, method.annotations, i, "Out"))
+                       << ">(reply.arguments().at(" << i << "));" << endl;
+                hs << "        }" << endl
+                   << "        return reply;" << endl
+                   << "    }" << endl;
+            }
+
+            hs << endl;
+        }
+
+        hs << "Q_SIGNALS: // SIGNALS" << endl;
+        foreach (const QDBusIntrospection::Signal &signal, interface->signals_) {
+            hs << "    ";
+            if (signal.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) ==
+                QLatin1String("true"))
+                hs << "Q_DECL_DEPRECATED ";
+
+            hs << "void " << signal.name << "(";
+
+            QStringList argNames = makeArgNames(signal.outputArgs);
+            writeArgList(hs, argNames, signal.annotations, signal.outputArgs);
+
+            hs << ");" << endl; // finished for header
+        }
+
+        // close the class:
+        hs << "};" << endl
+           << endl;
+    }
+
+    if (!skipNamespaces) {
+        QStringList last;
+        QDBusIntrospection::Interfaces::ConstIterator it = interfaces.constBegin();
+        do
+        {
+            QStringList current;
+            QString name;
+            if (it != interfaces.constEnd()) {
+                current = it->constData()->name.split(QLatin1Char('.'));
+                name = current.takeLast();
+            }
+
+            int i = 0;
+            while (i < current.count() && i < last.count() && current.at(i) == last.at(i))
+                ++i;
+
+            // i parts matched
+            // close last.arguments().count() - i namespaces:
+            for (int j = i; j < last.count(); ++j)
+                hs << QString((last.count() - j - 1 + i) * 2, QLatin1Char(' ')) << "}" << endl;
+
+            // open current.arguments().count() - i namespaces
+            for (int j = i; j < current.count(); ++j)
+                hs << QString(j * 2, QLatin1Char(' ')) << "namespace " << current.at(j) << " {" << endl;
+
+            // add this class:
+            if (!name.isEmpty()) {
+                hs << QString(current.count() * 2, QLatin1Char(' '))
+                   << "typedef ::" << classNameForInterface(it->constData()->name, Proxy)
+                   << " " << name << ";" << endl;
+            }
+
+            if (it == interfaces.constEnd())
+                break;
+            ++it;
+            last = current;
+        } while (true);
+    }
+
+    // close the include guard
+    hs << "#endif" << endl;
+
+    QString mocName = moc(filename);
+    if (includeMocs && !mocName.isEmpty())
+        cs << endl
+           << "#include \"" << mocName << "\"" << endl;
+
+    cs.flush();
+    hs.flush();
+
+    QFile file;
+    openFile(headerName, file);
+    file.write(headerData);
+
+    if (headerName == cppName) {
+        file.write(cppData);
+    } else {
+        QFile cppFile;
+        openFile(cppName, cppFile);
+        cppFile.write(cppData);
+    }
+}
+
+static void writeAdaptor(const QString &filename, const QDBusIntrospection::Interfaces &interfaces)
+{
+    // open the file
+    QString headerName = header(filename);
+    QByteArray headerData;
+    QTextStream hs(&headerData);
+
+    QString cppName = cpp(filename);
+    QByteArray cppData;
+    QTextStream cs(&cppData);
+
+    // write the headers
+    writeHeader(hs, false);
+    if (cppName != headerName)
+        writeHeader(cs, true);
+
+    // include guards:
+    QString includeGuard;
+    if (!headerName.isEmpty() && headerName != QLatin1String("-")) {
+        includeGuard = headerName.toUpper().replace(QLatin1Char('.'), QLatin1Char('_'));
+        int pos = includeGuard.lastIndexOf(QLatin1Char('/'));
+        if (pos != -1)
+            includeGuard = includeGuard.mid(pos + 1);
+    } else {
+        includeGuard = QLatin1String("QDBUSXML2CPP_ADAPTOR");
+    }
+    includeGuard = QString(QLatin1String("%1_%2"))
+                   .arg(includeGuard)
+                   .arg(QDateTime::currentDateTime().toTime_t());
+    hs << "#ifndef " << includeGuard << endl
+       << "#define " << includeGuard << endl
+       << endl;
+
+    // include our stuff:
+    hs << "#include <QtCore/QObject>" << endl;
+    if (cppName == headerName)
+        hs << "#include <QtCore/QMetaObject>" << endl
+           << "#include <QtCore/QVariant>" << endl;
+    hs << "#include <QtDBus/QtDBus>" << endl;
+
+    foreach (QString include, includes) {
+        hs << "#include \"" << include << "\"" << endl;
+        if (headerName.isEmpty())
+            cs << "#include \"" << include << "\"" << endl;
+    }
+
+    if (cppName != headerName) {
+        if (!headerName.isEmpty() && headerName != QLatin1String("-"))
+            cs << "#include \"" << headerName << "\"" << endl;
+
+        cs << "#include <QtCore/QMetaObject>" << endl
+           << includeList
+           << endl;
+        hs << forwardDeclarations;
+    } else {
+        hs << includeList;
+    }
+
+    hs << endl;
+
+    QString parent = parentClassName;
+    if (parentClassName.isEmpty())
+        parent = QLatin1String("QObject");
+
+    foreach (const QDBusIntrospection::Interface *interface, interfaces) {
+        QString className = classNameForInterface(interface->name, Adaptor);
+
+        // comment:
+        hs << "/*" << endl
+           << " * Adaptor class for interface " << interface->name << endl
+           << " */" << endl;
+        cs << "/*" << endl
+           << " * Implementation of adaptor class " << className << endl
+           << " */" << endl
+           << endl;
+
+        // class header:
+        hs << "class " << className << ": public QDBusAbstractAdaptor" << endl
+           << "{" << endl
+           << "    Q_OBJECT" << endl
+           << "    Q_CLASSINFO(\"D-Bus Interface\", \"" << interface->name << "\")" << endl
+           << "    Q_CLASSINFO(\"D-Bus Introspection\", \"\"" << endl
+           << stringify(interface->introspection)
+           << "        \"\")" << endl
+           << "public:" << endl
+           << "    " << className << "(" << parent << " *parent);" << endl
+           << "    virtual ~" << className << "();" << endl
+           << endl;
+
+        if (!parentClassName.isEmpty())
+            hs << "    inline " << parent << " *parent() const" << endl
+               << "    { return static_cast<" << parent << " *>(QObject::parent()); }" << endl
+               << endl;
+
+        // constructor/destructor
+        cs << className << "::" << className << "(" << parent << " *parent)" << endl
+           << "    : QDBusAbstractAdaptor(parent)" << endl
+           << "{" << endl
+           << "    // constructor" << endl
+           << "    setAutoRelaySignals(true);" << endl
+           << "}" << endl
+           << endl
+           << className << "::~" << className << "()" << endl
+           << "{" << endl
+           << "    // destructor" << endl
+           << "}" << endl
+           << endl;
+
+        hs << "public: // PROPERTIES" << endl;
+        foreach (const QDBusIntrospection::Property &property, interface->properties) {
+            QByteArray type = qtTypeName(property.type, property.annotations);
+            QString constRefType = constRefArg(type);
+            QString getter = propertyGetter(property);
+            QString setter = propertySetter(property);
+
+            hs << "    Q_PROPERTY(" << type << " " << property.name;
+            if (property.access != QDBusIntrospection::Property::Write)
+                hs << " READ " << getter;
+            if (property.access != QDBusIntrospection::Property::Read)
+                hs << " WRITE " << setter;
+            hs << ")" << endl;
+
+            // getter:
+            if (property.access != QDBusIntrospection::Property::Write) {
+                hs << "    " << type << " " << getter << "() const;" << endl;
+                cs << type << " "
+                   << className << "::" << getter << "() const" << endl
+                   << "{" << endl
+                   << "    // get the value of property " << property.name << endl
+                   << "    return qvariant_cast< " << type <<" >(parent()->property(\"" << property.name << "\"));" << endl
+                   << "}" << endl
+                   << endl;
+            }
+
+            // setter
+            if (property.access != QDBusIntrospection::Property::Read) {
+                hs << "    void " << setter << "(" << constRefType << "value);" << endl;
+                cs << "void " << className << "::" << setter << "(" << constRefType << "value)" << endl
+                   << "{" << endl
+                   << "    // set the value of property " << property.name << endl
+                   << "    parent()->setProperty(\"" << property.name << "\", qVariantFromValue(value";
+                if (constRefType.contains(QLatin1String("QDBusVariant")))
+                    cs << ".variant()";
+                cs << "));" << endl
+                   << "}" << endl
+                   << endl;
+            }
+
+            hs << endl;
+        }
+
+        hs << "public Q_SLOTS: // METHODS" << endl;
+        foreach (const QDBusIntrospection::Method &method, interface->methods) {
+            bool isNoReply =
+                method.annotations.value(QLatin1String(ANNOTATION_NO_WAIT)) == QLatin1String("true");
+            if (isNoReply && !method.outputArgs.isEmpty()) {
+                fprintf(stderr, "warning: method %s in interface %s is marked 'no-reply' but has output arguments.\n",
+                        qPrintable(method.name), qPrintable(interface->name));
+                continue;
+            }
+
+            hs << "    ";
+            if (method.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) ==
+                QLatin1String("true"))
+                hs << "Q_DECL_DEPRECATED ";
+
+            QByteArray returnType;
+            if (isNoReply) {
+                hs << "Q_NOREPLY void ";
+                cs << "void ";
+            } else if (method.outputArgs.isEmpty()) {
+                hs << "void ";
+                cs << "void ";
+            } else {
+                returnType = qtTypeName(method.outputArgs.first().type, method.annotations, 0, "Out");
+                hs << returnType << " ";
+                cs << returnType << " ";
+            }
+
+            QString name = method.name;
+            hs << name << "(";
+            cs << className << "::" << name << "(";
+
+            QStringList argNames = makeArgNames(method.inputArgs, method.outputArgs);
+            writeArgList(hs, argNames, method.annotations, method.inputArgs, method.outputArgs);
+            writeArgList(cs, argNames, method.annotations, method.inputArgs, method.outputArgs);
+
+            hs << ");" << endl; // finished for header
+            cs << ")" << endl
+               << "{" << endl
+               << "    // handle method call " << interface->name << "." << method.name << endl;
+
+            // make the call
+            bool usingInvokeMethod = false;
+            if (parentClassName.isEmpty() && method.inputArgs.count() <= 10
+                && method.outputArgs.count() <= 1)
+                usingInvokeMethod = true;
+
+            if (usingInvokeMethod) {
+                // we are using QMetaObject::invokeMethod
+                if (!returnType.isEmpty())
+                    cs << "    " << returnType << " " << argNames.at(method.inputArgs.count())
+                       << ";" << endl;
+
+                static const char invoke[] = "    QMetaObject::invokeMethod(parent(), \"";
+                cs << invoke << name << "\"";
+
+                if (!method.outputArgs.isEmpty())
+                    cs << ", Q_RETURN_ARG("
+                       << qtTypeName(method.outputArgs.at(0).type, method.annotations,
+                                     0, "Out")
+                       << ", "
+                       << argNames.at(method.inputArgs.count())
+                       << ")";
+
+                for (int i = 0; i < method.inputArgs.count(); ++i)
+                    cs << ", Q_ARG("
+                       << qtTypeName(method.inputArgs.at(i).type, method.annotations,
+                                     i, "In")
+                       << ", "
+                       << argNames.at(i)
+                       << ")";
+
+                cs << ");" << endl;
+
+                if (!returnType.isEmpty())
+                    cs << "    return " << argNames.at(method.inputArgs.count()) << ";" << endl;
+            } else {
+                if (parentClassName.isEmpty())
+                    cs << "    //";
+                else
+                    cs << "    ";
+
+                if (!method.outputArgs.isEmpty())
+                    cs << "return ";
+
+                if (parentClassName.isEmpty())
+                    cs << "static_cast<YourObjectType *>(parent())->";
+                else
+                    cs << "parent()->";
+                cs << name << "(";
+
+                int argPos = 0;
+                bool first = true;
+                for (int i = 0; i < method.inputArgs.count(); ++i) {
+                    cs << (first ? "" : ", ") << argNames.at(argPos++);
+                    first = false;
+                }
+                ++argPos;           // skip retval, if any
+                for (int i = 1; i < method.outputArgs.count(); ++i) {
+                    cs << (first ? "" : ", ") << argNames.at(argPos++);
+                    first = false;
+                }
+
+                cs << ");" << endl;
+            }
+            cs << "}" << endl
+               << endl;
+        }
+
+        hs << "Q_SIGNALS: // SIGNALS" << endl;
+        foreach (const QDBusIntrospection::Signal &signal, interface->signals_) {
+            hs << "    ";
+            if (signal.annotations.value(QLatin1String("org.freedesktop.DBus.Deprecated")) ==
+                QLatin1String("true"))
+                hs << "Q_DECL_DEPRECATED ";
+
+            hs << "void " << signal.name << "(";
+
+            QStringList argNames = makeArgNames(signal.outputArgs);
+            writeArgList(hs, argNames, signal.annotations, signal.outputArgs);
+
+            hs << ");" << endl; // finished for header
+        }
+
+        // close the class:
+        hs << "};" << endl
+           << endl;
+    }
+
+    // close the include guard
+    hs << "#endif" << endl;
+
+    QString mocName = moc(filename);
+    if (includeMocs && !mocName.isEmpty())
+        cs << endl
+           << "#include \"" << mocName << "\"" << endl;
+
+    cs.flush();
+    hs.flush();
+
+    QFile file;
+    openFile(headerName, file);
+    file.write(headerData);
+
+    if (headerName == cppName) {
+        file.write(cppData);
+    } else {
+        QFile cppFile;
+        openFile(cppName, cppFile);
+        cppFile.write(cppData);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    QCoreApplication app(argc, argv);
+    parseCmdLine(app.arguments());
+
+    QDBusIntrospection::Interfaces interfaces = readInput();
+    cleanInterfaces(interfaces);
+
+    if (!proxyFile.isEmpty() || adaptorFile.isEmpty())
+        writeProxy(proxyFile, interfaces);
+
+    if (!adaptorFile.isEmpty())
+        writeAdaptor(adaptorFile, interfaces);
+
+    return 0;
+}
+
+/*!
+    \page qdbusxml2cpp.html
+    \title QtDBus XML compiler (qdbusxml2cpp)
+    \keyword qdbusxml2cpp
+
+    The QtDBus XML compiler is a tool that can be used to parse interface descriptions and produce
+    static code representing those interfaces, which can then be used to make calls to remote
+    objects or implement said interfaces.
+
+    \c qdbusxml2dcpp has two modes of operation, that correspond to the two possible outputs it can
+    produce: the interface (proxy) class or the adaptor class. The latter consists of both a C++
+    header and a source file, which are meant to be edited and adapted to your needs.
+
+    The \c qdbusxml2dcpp tool is not meant to be run every time you compile your
+    application. Instead, it's meant to be used when developing the code or when the interface
+    changes.
+
+    The adaptor classes generated by \c qdbusxml2cpp are just a skeleton that must be completed. It
+    generates, by default, calls to slots with the same name on the object the adaptor is attached
+    to. However, you may modify those slots or the property accessor functions to suit your needs.
+*/
diff --git a/tools/qdbus/qdbusxml2cpp/qdbusxml2cpp.pro b/tools/qdbus/qdbusxml2cpp/qdbusxml2cpp.pro
new file mode 100644
index 0000000..6f78c7c
--- /dev/null
+++ b/tools/qdbus/qdbusxml2cpp/qdbusxml2cpp.pro
@@ -0,0 +1,10 @@
+SOURCES = qdbusxml2cpp.cpp
+DESTDIR = ../../../bin
+TARGET = qdbusxml2cpp
+QT = core xml
+CONFIG += qdbus
+CONFIG -= app_bundle
+win32:CONFIG += console
+
+target.path=$$[QT_INSTALL_BINS]
+INSTALLS += target