Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 419 insertions, 0 deletions

diff --git a/src/dbus/qdbusconnectioninterface.cpp b/src/dbus/qdbusconnectioninterface.cpp
new file mode 100644
index 0000000000..92263356c3
--- /dev/null
+++ b/src/dbus/qdbusconnectioninterface.cpp
@@ -0,0 +1,419 @@
+/****************************************************************************
+**
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDBus module 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 Technology Preview License Agreement accompanying
+** this package.
+**
+** 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdbusconnectioninterface.h"
+
+#include <QtCore/QByteArray>
+#include <QtCore/QList>
+#include <QtCore/QMap>
+#include <QtCore/QString>
+#include <QtCore/QStringList>
+#include <QtCore/QVariant>
+#include <QtCore/QDebug>
+
+#include "qdbus_symbols_p.h"          // for the DBUS_* constants
+
+#ifndef QT_NO_DBUS
+
+QT_BEGIN_NAMESPACE
+
+/*
+ * Implementation of interface class QDBusConnectionInterface
+ */
+
+/*!
+    \class QDBusConnectionInterface
+    \inmodule QtDBus
+    \since 4.2
+
+    \brief The QDBusConnectionInterface class provides access to the D-Bus bus daemon service.
+
+    The D-Bus bus server daemon provides one special interface \c
+    org.freedesktop.DBus that allows clients to access certain
+    properties of the bus, such as the current list of clients
+    connected. The QDBusConnectionInterface class provides access to that
+    interface.
+
+    The most common uses of this class are to register and unregister
+    service names on the bus using the registerService() and
+    unregisterService() functions, query about existing names using
+    the isServiceRegistered(), registeredServiceNames() and
+    serviceOwner() functions, and to receive notification that a
+    client has registered or de-registered through the
+    serviceRegistered(), serviceUnregistered() and serviceOwnerChanged()
+    signals.
+*/
+
+/*!
+    \enum QDBusConnectionInterface::ServiceQueueOptions
+
+    Flags for determining how a service registration should behave, in
+    case the service name is already registered.
+
+    \value DontQueueService     If an application requests a name that
+                                is already owned, no queueing will be
+                                performed. The registeredService()
+                                call will simply fail.
+                                This is the default.
+
+    \value QueueService         Attempts to register the requested
+                                service, but do not try to replace it
+                                if another application already has it
+                                registered. Instead, simply put this
+                                application in queue, until it is
+                                given up. The serviceRegistered()
+                                signal will be emitted when that
+                                happens.
+
+    \value ReplaceExistingService If another application already has
+                                the service name registered, attempt
+                                to replace it.
+
+    \sa ServiceReplacementOptions
+*/
+
+/*!
+    \enum QDBusConnectionInterface::ServiceReplacementOptions
+
+    Flags for determining if the D-Bus server should allow another
+    application to replace a name that this application has registered
+    with the ReplaceExistingService option.
+
+    The possible values are:
+
+    \value DontAllowReplacement Do not allow another application to
+                                replace us. The service must be
+                                explicitly unregistered with
+                                unregisterService() for another
+                                application to acquire it.
+                                This is the default.
+
+    \value AllowReplacement     Allow other applications to replace us
+                                with the ReplaceExistingService option
+                                to registerService() without
+                                intervention. If that happens, the
+                                serviceUnregistered() signal will be
+                                emitted.
+
+    \sa ServiceQueueOptions
+*/
+
+/*!
+    \enum QDBusConnectionInterface::RegisterServiceReply
+
+    The possible return values from registerService():
+
+    \value ServiceNotRegistered The call failed and the service name was not registered.
+    \value ServiceRegistered    The caller is now the owner of the service name.
+    \value ServiceQueued        The caller specified the QueueService flag and the
+                                service was already registered, so we are in queue.
+
+    The serviceRegistered() signal will be emitted when the service is
+    acquired by this application.
+*/
+
+/*!
+    \internal
+*/
+const char *QDBusConnectionInterface::staticInterfaceName()
+{ return "org.freedesktop.DBus"; }
+
+/*!
+    \internal
+*/
+QDBusConnectionInterface::QDBusConnectionInterface(const QDBusConnection &connection,
+                                                   QObject *parent)
+    : QDBusAbstractInterface(QLatin1String(DBUS_SERVICE_DBUS),
+                             QLatin1String(DBUS_PATH_DBUS),
+                             DBUS_INTERFACE_DBUS, connection, parent)
+{
+    connect(this, SIGNAL(NameAcquired(QString)), this, SIGNAL(serviceRegistered(QString)));
+    connect(this, SIGNAL(NameLost(QString)), this, SIGNAL(serviceUnregistered(QString)));
+    connect(this, SIGNAL(NameOwnerChanged(QString,QString,QString)),
+            this, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
+}
+
+/*!
+    \internal
+*/
+QDBusConnectionInterface::~QDBusConnectionInterface()
+{
+}
+
+/*!
+    Returns the unique connection name of the primary owner of the
+    name \a name. If the requested name doesn't have an owner, returns
+    a \c org.freedesktop.DBus.Error.NameHasNoOwner error.
+*/
+QDBusReply<QString> QDBusConnectionInterface::serviceOwner(const QString &name) const
+{
+    return internalConstCall(QDBus::AutoDetect, QLatin1String("GetNameOwner"), QList<QVariant>() << name);
+}
+
+/*!
+  \property QDBusConnectionInterface::registeredServiceNames
+  \brief holds the registered service names
+
+  Lists all names currently registered on the bus.
+*/
+QDBusReply<QStringList> QDBusConnectionInterface::registeredServiceNames() const
+{
+    return internalConstCall(QDBus::AutoDetect, QLatin1String("ListNames"));
+}
+
+/*!
+    Returns true if the service name \a serviceName has is currently
+    registered.
+*/
+QDBusReply<bool> QDBusConnectionInterface::isServiceRegistered(const QString &serviceName) const
+{
+    return internalConstCall(QDBus::AutoDetect, QLatin1String("NameHasOwner"),
+                             QList<QVariant>() << serviceName);
+}
+
+/*!
+    Returns the Unix Process ID (PID) for the process currently
+    holding the bus service \a serviceName.
+*/
+QDBusReply<uint> QDBusConnectionInterface::servicePid(const QString &serviceName) const
+{
+    return internalConstCall(QDBus::AutoDetect, QLatin1String("GetConnectionUnixProcessID"),
+                             QList<QVariant>() << serviceName);
+}
+
+/*!
+    Returns the Unix User ID (UID) for the process currently holding
+    the bus service \a serviceName.
+*/
+QDBusReply<uint> QDBusConnectionInterface::serviceUid(const QString &serviceName) const
+{
+    return internalConstCall(QDBus::AutoDetect, QLatin1String("GetConnectionUnixUser"),
+                             QList<QVariant>() << serviceName);
+}
+
+/*!
+    Requests that the bus start the service given by the name \a name.
+*/
+QDBusReply<void> QDBusConnectionInterface::startService(const QString &name)
+{
+    return call(QLatin1String("StartServiceByName"), name, uint(0));
+}
+
+/*!
+    Requests to register the service name \a serviceName on the
+    bus. The \a qoption flag specifies how the D-Bus server should behave
+    if \a serviceName is already registered. The \a roption flag
+    specifies if the server should allow another application to
+    replace our registered name.
+
+    If the service registration succeeds, the serviceRegistered()
+    signal will be emitted. If we are placed in queue, the signal will
+    be emitted when we obtain the name. If \a roption is
+    AllowReplacement, the serviceUnregistered() signal will be emitted
+    if another application replaces this one.
+
+    \sa unregisterService()
+*/
+QDBusReply<QDBusConnectionInterface::RegisterServiceReply>
+QDBusConnectionInterface::registerService(const QString &serviceName,
+                                          ServiceQueueOptions qoption,
+                                          ServiceReplacementOptions roption)
+{
+    // reconstruct the low-level flags
+    uint flags = 0;
+    switch (qoption) {
+    case DontQueueService:
+        flags = DBUS_NAME_FLAG_DO_NOT_QUEUE;
+        break;
+    case QueueService:
+        flags = 0;
+        break;
+    case ReplaceExistingService:
+        flags = DBUS_NAME_FLAG_DO_NOT_QUEUE | DBUS_NAME_FLAG_REPLACE_EXISTING;
+        break;
+    }
+
+    switch (roption) {
+    case DontAllowReplacement:
+        break;
+    case AllowReplacement:
+        flags |= DBUS_NAME_FLAG_ALLOW_REPLACEMENT;
+        break;
+    }
+
+    QDBusMessage reply = call(QLatin1String("RequestName"), serviceName, flags);
+//    qDebug() << "QDBusConnectionInterface::registerService" << serviceName << "Reply:" << reply;
+
+    // convert the low-level flags to something that we can use
+    if (reply.type() == QDBusMessage::ReplyMessage) {
+        uint code = 0;
+
+        switch (reply.arguments().at(0).toUInt()) {
+        case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
+        case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
+            code = uint(ServiceRegistered);
+            break;
+
+        case DBUS_REQUEST_NAME_REPLY_EXISTS:
+            code = uint(ServiceNotRegistered);
+            break;
+
+        case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
+            code = uint(ServiceQueued);
+            break;
+        }
+
+        reply.setArguments(QVariantList() << code);
+    }
+
+    return reply;
+}
+
+/*!
+    Releases the claim on the bus service name \a serviceName, that
+    had been previously registered with registerService(). If this
+    application had ownership of the name, it will be released for
+    other applications to claim. If it only had the name queued, it
+    gives up its position in the queue.
+*/
+QDBusReply<bool>
+QDBusConnectionInterface::unregisterService(const QString &serviceName)
+{
+    QDBusMessage reply = call(QLatin1String("ReleaseName"), serviceName);
+    if (reply.type() == QDBusMessage::ReplyMessage) {
+        bool success = reply.arguments().at(0).toUInt() == DBUS_RELEASE_NAME_REPLY_RELEASED;
+        reply.setArguments(QVariantList() << success);
+    }
+    return reply;
+}
+
+/*!
+    \internal
+*/
+void QDBusConnectionInterface::connectNotify(const char *signalName)
+{
+    // translate the signal names to what we really want
+    // this avoids setting hooks for signals that don't exist on the bus
+    if (qstrcmp(signalName, SIGNAL(serviceRegistered(QString))) == 0)
+        QDBusAbstractInterface::connectNotify(SIGNAL(NameAcquired(QString)));
+
+    else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0)
+        QDBusAbstractInterface::connectNotify(SIGNAL(NameLost(QString)));
+
+    else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0) {
+        static bool warningPrinted = false;
+        if (!warningPrinted) {
+            qWarning("Connecting to deprecated signal QDBusConnectionInterface::serviceOwnerChanged(QString,QString,QString)");
+            warningPrinted = true;
+        }
+        QDBusAbstractInterface::connectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString)));
+    }
+}
+
+/*!
+    \internal
+*/
+void QDBusConnectionInterface::disconnectNotify(const char *signalName)
+{
+    // translate the signal names to what we really want
+    // this avoids setting hooks for signals that don't exist on the bus
+    if (qstrcmp(signalName, SIGNAL(serviceRegistered(QString))) == 0)
+        QDBusAbstractInterface::disconnectNotify(SIGNAL(NameAcquired(QString)));
+
+    else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0)
+        QDBusAbstractInterface::disconnectNotify(SIGNAL(NameLost(QString)));
+
+    else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0)
+        QDBusAbstractInterface::disconnectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString)));
+}
+
+// signals
+/*!
+    \fn QDBusConnectionInterface::serviceRegistered(const QString &serviceName)
+
+    This signal is emitted by the D-Bus server when the bus service
+    name (unique connection name or well-known service name) given by
+    \a serviceName is acquired by this application.
+
+    Acquisition happens after this application has requested a name using
+    registerService().
+*/
+
+/*!
+    \fn QDBusConnectionInterface::serviceUnregistered(const QString &serviceName)
+
+    This signal is emitted by the D-Bus server when this application
+    loses ownership of the bus service name given by \a serviceName.
+*/
+
+/*!
+    \fn QDBusConnectionInterface::serviceOwnerChanged(const QString &name, const QString &oldOwner, const QString &newOwner)
+
+    This signal is emitted by the D-Bus server whenever a service
+    ownership change happens in the bus, including apparition and
+    disparition of names.
+
+    This signal means the application \a oldOwner lost ownership of
+    bus name \a name to application \a newOwner. If \a oldOwner is an
+    empty string, it means the name \a name has just been created; if
+    \a newOwner is empty, the name \a name has no current owner and is
+    no longer available.
+
+    \note connecting to this signal will make the application listen for and
+    receive every single service ownership change on the bus. Depending on
+    how many services are running, this make the application be activated to
+    receive more signals than it needs. To avoid this problem, use the
+    QDBusServiceWatcher class, which can listen for specific changes.
+*/
+
+/*!
+  \fn void QDBusConnectionInterface::callWithCallbackFailed(const QDBusError &error, const QDBusMessage &call)
+
+  This signal is emitted when there is an error during a
+  QDBusConnection::callWithCallback(). \a error specifies the error.
+  \a call is the message that couldn't be delivered.
+
+  \sa QDBusConnection::callWithCallback()
+ */
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_DBUS