[telepathy-qt4/master] Renamed high-level classes namespace from Telepathy::Client to Telepathy.
Andre Moreira Magalhaes (andrunko)
andre.magalhaes at collabora.co.uk
Tue Apr 7 22:00:47 PDT 2009
---
TelepathyQt4/PendingContactAttributes | 7 +
TelepathyQt4/abstract-interface.cpp | 9 +-
TelepathyQt4/abstract-interface.h | 5 +-
TelepathyQt4/account-manager.cpp | 19 +--
TelepathyQt4/account-manager.h | 9 +-
TelepathyQt4/account.cpp | 17 +-
TelepathyQt4/account.h | 15 +-
TelepathyQt4/channel.cpp | 29 ++--
TelepathyQt4/channel.h | 71 ++++----
TelepathyQt4/connection-internal.h | 5 +-
TelepathyQt4/connection-manager-internal.h | 6 +-
TelepathyQt4/connection-manager.cpp | 9 +-
TelepathyQt4/connection-manager.h | 9 +-
TelepathyQt4/connection.cpp | 39 ++---
TelepathyQt4/connection.h | 39 ++---
TelepathyQt4/constants.h | 6 +-
TelepathyQt4/contact-manager.cpp | 45 +++---
TelepathyQt4/contact-manager.h | 35 ++--
TelepathyQt4/contact.cpp | 3 -
TelepathyQt4/contact.h | 9 +-
TelepathyQt4/dbus-proxy.cpp | 7 +-
TelepathyQt4/dbus-proxy.h | 5 +-
TelepathyQt4/debug.cpp | 2 +-
TelepathyQt4/feature.cpp | 3 -
TelepathyQt4/feature.h | 3 -
TelepathyQt4/file-transfer.cpp | 3 -
TelepathyQt4/file-transfer.h | 3 -
TelepathyQt4/key-file.cpp | 2 +-
TelepathyQt4/manager-file.cpp | 2 +-
TelepathyQt4/message.cpp | 3 -
TelepathyQt4/message.h | 4 +-
TelepathyQt4/optional-interface-factory.cpp | 5 +-
TelepathyQt4/optional-interface-factory.h | 5 +-
TelepathyQt4/pending-account.cpp | 3 -
TelepathyQt4/pending-account.h | 3 -
TelepathyQt4/pending-channel.cpp | 3 -
TelepathyQt4/pending-channel.h | 3 -
TelepathyQt4/pending-connection.cpp | 3 -
TelepathyQt4/pending-connection.h | 3 -
TelepathyQt4/pending-contact-attributes.cpp | 3 -
TelepathyQt4/pending-contact-attributes.h | 13 +-
TelepathyQt4/pending-contacts.cpp | 23 +--
TelepathyQt4/pending-contacts.h | 11 +-
TelepathyQt4/pending-handles.cpp | 3 -
TelepathyQt4/pending-handles.h | 3 -
TelepathyQt4/pending-operation.cpp | 5 -
TelepathyQt4/pending-operation.h | 6 +-
TelepathyQt4/pending-ready.cpp | 3 -
TelepathyQt4/pending-ready.h | 3 -
TelepathyQt4/pending-string-list.cpp | 3 -
TelepathyQt4/pending-string-list.h | 3 -
TelepathyQt4/properties.cpp | 4 +-
TelepathyQt4/readiness-helper.cpp | 18 +-
TelepathyQt4/readiness-helper.h | 7 +-
TelepathyQt4/ready-object.cpp | 3 -
TelepathyQt4/ready-object.h | 3 -
TelepathyQt4/referenced-handles.cpp | 5 +-
TelepathyQt4/referenced-handles.h | 6 +-
TelepathyQt4/room-list.cpp | 3 -
TelepathyQt4/room-list.h | 3 -
TelepathyQt4/simple-pending-operations.h | 7 -
TelepathyQt4/streamed-media-channel.cpp | 21 +--
TelepathyQt4/streamed-media-channel.h | 21 +--
TelepathyQt4/text-channel.cpp | 13 +-
TelepathyQt4/text-channel.h | 11 +-
TelepathyQt4/types.cpp | 3 +-
TelepathyQt4/types.h | 3 -
examples/accounts/account-item.cpp | 12 +-
examples/accounts/account-item.h | 8 +-
examples/accounts/accounts-window.cpp | 8 +-
examples/accounts/accounts-window.h | 6 +-
examples/call/call-handler.cpp | 14 +-
examples/call/call-handler.h | 14 +-
examples/call/call-roster-widget.cpp | 2 +-
examples/call/call-roster-widget.h | 4 +-
examples/call/call-widget.cpp | 46 +++---
examples/call/call-widget.h | 40 ++---
examples/call/call-window.cpp | 24 ++--
examples/call/call-window.h | 14 +-
examples/call/farsight-channel.cpp | 4 +-
examples/call/farsight-channel.h | 8 +-
examples/call/main.cpp | 2 +-
examples/call/video-widget.cpp | 4 +-
examples/call/video-widget.h | 2 -
examples/extensions/Makefile.am | 4 +-
examples/roster/roster-item.cpp | 6 +-
examples/roster/roster-item.h | 6 +-
examples/roster/roster-widget.cpp | 18 +-
examples/roster/roster-widget.h | 18 +-
examples/roster/roster-window.cpp | 24 ++--
examples/roster/roster-window.h | 14 +-
tests/dbus/account-basics.cpp | 46 +++---
tests/dbus/chan-basics.cpp | 46 +++---
tests/dbus/chan-group.cpp | 74 ++++----
tests/dbus/cm-basics.cpp | 12 +-
tests/dbus/conn-basics.cpp | 16 +-
tests/dbus/conn-requests.cpp | 34 ++--
tests/dbus/conn-roster.cpp | 36 ++--
tests/dbus/contacts.cpp | 54 +++---
tests/dbus/handles.cpp | 22 ++--
tests/dbus/stateful-proxy.cpp | 20 +-
tests/dbus/streamed-media-chan.cpp | 238 +++++++++++++-------------
tests/dbus/text-chan.cpp | 52 +++---
tests/lib/test.cpp | 13 +-
tests/lib/test.h | 7 +-
tests/pinocchio/cm-basics.cpp | 26 ++--
tests/pinocchio/conn-basics.cpp | 36 ++--
tests/pinocchio/handles.cpp | 37 ++--
tests/pinocchio/lib.cpp | 2 +-
tools/qt4-client-gen.py | 22 ++--
110 files changed, 773 insertions(+), 983 deletions(-)
diff --git a/TelepathyQt4/PendingContactAttributes b/TelepathyQt4/PendingContactAttributes
index 3c7db75..9bbb839 100644
--- a/TelepathyQt4/PendingContactAttributes
+++ b/TelepathyQt4/PendingContactAttributes
@@ -1,6 +1,13 @@
#ifndef _TelepathyQt4_Client_PendingContactAttributes_HEADER_GUARD_
#define _TelepathyQt4_Client_PendingContactAttributes_HEADER_GUARD_
+#ifndef IN_TELEPATHY_QT4_HEADER
+#define IN_TELEPATHY_QT4_HEADER
+#endif
+
#include <TelepathyQt4/pending-contact-attributes.h>
+#undef IN_TELEPATHY_QT4_HEADER
+
#endif
+// vim:set ft=cpp:
diff --git a/TelepathyQt4/abstract-interface.cpp b/TelepathyQt4/abstract-interface.cpp
index 7919fcc..4dcaccd 100644
--- a/TelepathyQt4/abstract-interface.cpp
+++ b/TelepathyQt4/abstract-interface.cpp
@@ -27,8 +27,6 @@
namespace Telepathy
{
-namespace Client
-{
struct AbstractInterface::Private
{
@@ -55,8 +53,8 @@ AbstractInterface::AbstractInterface(DBusProxy *parent, const char *interface)
interface, parent->dbusConnection(), parent),
mPriv(new Private())
{
- connect(parent, SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
- this, SLOT(invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &)));
+ connect(parent, SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
+ this, SLOT(invalidate(Telepathy::DBusProxy *, const QString &, const QString &)));
}
AbstractInterface::~AbstractInterface()
@@ -79,7 +77,7 @@ QString AbstractInterface::invalidationMessage() const
return mPriv->mMessage;
}
-void AbstractInterface::invalidate(Telepathy::Client::DBusProxy *proxy,
+void AbstractInterface::invalidate(Telepathy::DBusProxy *proxy,
const QString &error, const QString &message)
{
Q_ASSERT(!error.isEmpty());
@@ -90,5 +88,4 @@ void AbstractInterface::invalidate(Telepathy::Client::DBusProxy *proxy,
}
}
-} // Client
} // Telepathy
diff --git a/TelepathyQt4/abstract-interface.h b/TelepathyQt4/abstract-interface.h
index 781a3ae..b39f432 100644
--- a/TelepathyQt4/abstract-interface.h
+++ b/TelepathyQt4/abstract-interface.h
@@ -29,8 +29,6 @@
namespace Telepathy
{
-namespace Client
-{
class DBusProxy;
@@ -47,7 +45,7 @@ public:
QString invalidationMessage() const;
protected Q_SLOTS:
- virtual void invalidate(Telepathy::Client::DBusProxy *proxy,
+ virtual void invalidate(Telepathy::DBusProxy *proxy,
const QString &error, const QString &message);
protected:
@@ -61,7 +59,6 @@ private:
Private *mPriv;
};
-} // Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/account-manager.cpp b/TelepathyQt4/account-manager.cpp
index 8b8c7f2..bac6767 100644
--- a/TelepathyQt4/account-manager.cpp
+++ b/TelepathyQt4/account-manager.cpp
@@ -57,8 +57,6 @@
namespace Telepathy
{
-namespace Client
-{
struct AccountManager::Private
{
@@ -75,7 +73,7 @@ struct AccountManager::Private
AccountManager *parent;
// Instance of generated interface class
- AccountManagerInterface *baseInterface;
+ Client::AccountManagerInterface *baseInterface;
ReadinessHelper *readinessHelper;
@@ -88,7 +86,7 @@ struct AccountManager::Private
AccountManager::Private::Private(AccountManager *parent)
: parent(parent),
- baseInterface(new AccountManagerInterface(parent->dbusConnection(),
+ baseInterface(new Client::AccountManagerInterface(parent->dbusConnection(),
parent->busName(), parent->objectPath(), parent)),
readinessHelper(parent->readinessHelper())
{
@@ -208,7 +206,7 @@ void AccountManager::Private::setAccountPaths(QSet<QString> &set,
* ~MyClass() { }
*
* private Q_SLOTS:
- * void onAccountManagerReady(Telepathy::Client::PendingOperation*);
+ * void onAccountManagerReady(Telepathy::PendingOperation*);
*
* private:
* AccountManagerPtr am;
@@ -219,11 +217,11 @@ void AccountManager::Private::setAccountPaths(QSet<QString> &set,
* am(AccountManager::create())
* {
* connect(am->becomeReady(),
- * SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- * SLOT(onAccountManagerReady(Telepathy::Client::PendingOperation*)));
+ * SIGNAL(finished(Telepathy::PendingOperation*)),
+ * SLOT(onAccountManagerReady(Telepathy::PendingOperation*)));
* }
*
- * void MyClass::onAccountManagerReady(Telepathy::Client::PendingOperation *op)
+ * void MyClass::onAccountManagerReady(Telepathy::PendingOperation *op)
* {
* if (op->isError()) {
* qWarning() << "Account manager cannot become ready:" <<
@@ -489,7 +487,7 @@ PendingAccount *AccountManager::createAccount(const QString &connectionManager,
* \return A pointer to the existing AccountManagerInterface for this
* AccountManager.
*/
-AccountManagerInterface *AccountManager::baseInterface() const
+Client::AccountManagerInterface *AccountManager::baseInterface() const
{
return mPriv->baseInterface;
}
@@ -538,7 +536,7 @@ void AccountManager::Private::init()
void AccountManager::Private::introspectMain(AccountManager::Private *self)
{
- DBus::PropertiesInterface *properties = self->parent->propertiesInterface();
+ Client::DBus::PropertiesInterface *properties = self->parent->propertiesInterface();
Q_ASSERT(properties != 0);
debug() << "Calling Properties::GetAll(AccountManager)";
@@ -629,5 +627,4 @@ void AccountManager::onAccountRemoved(const QDBusObjectPath &objectPath)
emit accountRemoved(path);
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/account-manager.h b/TelepathyQt4/account-manager.h
index 0d127b6..20b4fbe 100644
--- a/TelepathyQt4/account-manager.h
+++ b/TelepathyQt4/account-manager.h
@@ -44,8 +44,6 @@
namespace Telepathy
{
-namespace Client
-{
class AccountManager;
class PendingAccount;
@@ -69,9 +67,9 @@ public:
QStringList interfaces() const;
- inline DBus::PropertiesInterface *propertiesInterface() const
+ inline Client::DBus::PropertiesInterface *propertiesInterface() const
{
- return OptionalInterfaceFactory<AccountManager>::interface<DBus::PropertiesInterface>();
+ return OptionalInterfaceFactory<AccountManager>::interface<Client::DBus::PropertiesInterface>();
}
QStringList validAccountPaths() const;
@@ -100,7 +98,7 @@ protected:
AccountManager();
AccountManager(const QDBusConnection &bus);
- AccountManagerInterface *baseInterface() const;
+ Client::AccountManagerInterface *baseInterface() const;
private Q_SLOTS:
void gotMainProperties(QDBusPendingCallWatcher *);
@@ -114,7 +112,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/account.cpp b/TelepathyQt4/account.cpp
index b75e2ff..c00a927 100644
--- a/TelepathyQt4/account.cpp
+++ b/TelepathyQt4/account.cpp
@@ -52,8 +52,6 @@
namespace Telepathy
{
-namespace Client
-{
struct Account::Private
{
@@ -73,7 +71,7 @@ struct Account::Private
Account *parent;
// Instance of generated interface class
- AccountInterface *baseInterface;
+ Client::AccountInterface *baseInterface;
ReadinessHelper *readinessHelper;
@@ -103,7 +101,7 @@ struct Account::Private
Account::Private::Private(Account *parent)
: parent(parent),
- baseInterface(new AccountInterface(parent->dbusConnection(),
+ baseInterface(new Client::AccountInterface(parent->dbusConnection(),
parent->busName(), parent->objectPath(), parent)),
readinessHelper(parent->readinessHelper()),
valid(false),
@@ -717,7 +715,7 @@ QStringList Account::interfaces() const
* \return A pointer to the existing AccountInterface for this
* Account.
*/
-AccountInterface *Account::baseInterface() const
+Client::AccountInterface *Account::baseInterface() const
{
return mPriv->baseInterface;
}
@@ -739,7 +737,7 @@ void Account::Private::init()
void Account::Private::introspectMain(Account::Private *self)
{
- DBus::PropertiesInterface *properties = self->parent->propertiesInterface();
+ Client::DBus::PropertiesInterface *properties = self->parent->propertiesInterface();
Q_ASSERT(properties != 0);
debug() << "Calling Properties::GetAll(Account)";
@@ -756,7 +754,7 @@ void Account::Private::introspectAvatar(Account::Private *self)
debug() << "Calling GetAvatar(Account)";
// we already checked if avatar interface exists, so bypass avatar interface
// checking
- AccountInterfaceAvatarInterface *iface =
+ Client::AccountInterfaceAvatarInterface *iface =
self->parent->avatarInterface(BypassInterfaceCheck);
// If we are here it means the user cares about avatar, so
@@ -777,8 +775,8 @@ void Account::Private::introspectProtocolInfo(Account::Private *self)
self->parent->dbusConnection(),
self->cmName);
self->parent->connect(self->cm->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onConnectionManagerReady(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onConnectionManagerReady(Telepathy::PendingOperation *)));
}
void Account::Private::updateProperties(const QVariantMap &props)
@@ -1032,5 +1030,4 @@ void Account::onRemoved()
QLatin1String("Account removed from AccountManager"));
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/account.h b/TelepathyQt4/account.h
index ea827ff..0b68e63 100644
--- a/TelepathyQt4/account.h
+++ b/TelepathyQt4/account.h
@@ -45,8 +45,6 @@
namespace Telepathy
{
-namespace Client
-{
class Account;
class Connection;
@@ -148,15 +146,15 @@ public:
return OptionalInterfaceFactory<Account>::interface<Interface>();
}
- inline DBus::PropertiesInterface *propertiesInterface() const
+ inline Client::DBus::PropertiesInterface *propertiesInterface() const
{
- return optionalInterface<DBus::PropertiesInterface>(BypassInterfaceCheck);
+ return optionalInterface<Client::DBus::PropertiesInterface>(BypassInterfaceCheck);
}
- inline AccountInterfaceAvatarInterface *avatarInterface(
+ inline Client::AccountInterfaceAvatarInterface *avatarInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<AccountInterfaceAvatarInterface>(check);
+ return optionalInterface<Client::AccountInterfaceAvatarInterface>(check);
}
Q_SIGNALS:
@@ -181,13 +179,13 @@ protected:
Account(const QDBusConnection &bus,
const QString &busName, const QString &objectPath);
- AccountInterface *baseInterface() const;
+ Client::AccountInterface *baseInterface() const;
private Q_SLOTS:
void gotMainProperties(QDBusPendingCallWatcher *);
void gotAvatar(QDBusPendingCallWatcher *);
void onAvatarChanged();
- void onConnectionManagerReady(Telepathy::Client::PendingOperation *);
+ void onConnectionManagerReady(Telepathy::PendingOperation *);
void onPropertyChanged(const QVariantMap &delta);
void onRemoved();
@@ -197,7 +195,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/channel.cpp b/TelepathyQt4/channel.cpp
index 0b40564..75ca9bd 100644
--- a/TelepathyQt4/channel.cpp
+++ b/TelepathyQt4/channel.cpp
@@ -61,8 +61,6 @@
namespace Telepathy
{
-namespace Client
-{
struct Channel::Private
{
@@ -100,15 +98,15 @@ struct Channel::Private
Channel *parent;
// Instance of generated interface class
- ChannelInterface *baseInterface;
+ Client::ChannelInterface *baseInterface;
// Owning connection - it can be a SharedPtr as Connection does not cache
// channels
ConnectionPtr connection;
// Optional interface proxies
- ChannelInterfaceGroupInterface *group;
- DBus::PropertiesInterface *properties;
+ Client::ChannelInterfaceGroupInterface *group;
+ Client::DBus::PropertiesInterface *properties;
ReadinessHelper *readinessHelper;
@@ -200,7 +198,7 @@ struct Channel::Private::GroupMembersChangedInfo
Channel::Private::Private(Channel *parent, const ConnectionPtr &connection)
: parent(parent),
- baseInterface(new ChannelInterface(parent->dbusConnection(),
+ baseInterface(new Client::ChannelInterface(parent->dbusConnection(),
parent->busName(), parent->objectPath(), parent)),
connection(connection),
group(0),
@@ -230,7 +228,7 @@ Channel::Private::Private(Channel *parent, const ConnectionPtr &connection)
debug() << " Connection to owning connection's lifetime signals";
parent->connect(connection.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
SLOT(onConnectionInvalidated()));
@@ -650,8 +648,8 @@ void Channel::Private::buildContacts()
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence);
parent->connect(pendingContacts,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(gotContacts(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(gotContacts(Telepathy::PendingOperation *)));
}
void Channel::Private::processMembersChanged()
@@ -1593,10 +1591,10 @@ PendingOperation *Channel::groupAddSelfHandle()
/**
* \fn void Channel::groupMembersChanged(
- * const Telepathy::Client::Contacts &groupMembersAdded,
- * const Telepathy::Client::Contacts &groupLocalPendingMembersAdded,
- * const Telepathy::Client::Contacts &groupRemotePendingMembersAdded,
- * const Telepathy::Client::Contacts &groupMembersRemoved,
+ * const Telepathy::Contacts &groupMembersAdded,
+ * const Telepathy::Contacts &groupLocalPendingMembersAdded,
+ * const Telepathy::Contacts &groupRemotePendingMembersAdded,
+ * const Telepathy::Contacts &groupMembersRemoved,
* const Channel::GroupMemberChangeDetails &details);
*
* Emitted when the value returned by groupContacts(), groupLocalPendingContacts() or
@@ -1812,7 +1810,7 @@ PendingOperation *Channel::groupAddSelfHandle()
*
* \return A pointer to the existing ChannelInterface for this Channel
*/
-ChannelInterface *Channel::baseInterface() const
+Client::ChannelInterface *Channel::baseInterface() const
{
return mPriv->baseInterface;
}
@@ -2292,5 +2290,4 @@ void Channel::continueIntrospection()
* \return The message as a string.
*/
-}
-}
+} // Telepathy
diff --git a/TelepathyQt4/channel.h b/TelepathyQt4/channel.h
index e060fc6..e860112 100644
--- a/TelepathyQt4/channel.h
+++ b/TelepathyQt4/channel.h
@@ -43,8 +43,6 @@
namespace Telepathy
{
-namespace Client
-{
class Connection;
class PendingOperation;
@@ -147,11 +145,11 @@ Q_SIGNALS:
void groupCanRescindContactsChanged(bool canRescindContacts);
void groupMembersChanged(
- const Telepathy::Client::Contacts &groupMembersAdded,
- const Telepathy::Client::Contacts &groupLocalPendingMembersAdded,
- const Telepathy::Client::Contacts &groupRemotePendingMembersAdded,
- const Telepathy::Client::Contacts &groupMembersRemoved,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &details);
+ const Telepathy::Contacts &groupMembersAdded,
+ const Telepathy::Contacts &groupLocalPendingMembersAdded,
+ const Telepathy::Contacts &groupRemotePendingMembersAdded,
+ const Telepathy::Contacts &groupMembersRemoved,
+ const Telepathy::Channel::GroupMemberChangeDetails &details);
void groupHandleOwnersChanged(const Telepathy::HandleOwnerMap &owners,
const Telepathy::UIntList &added, const Telepathy::UIntList &removed);
@@ -178,51 +176,51 @@ public:
return OptionalInterfaceFactory<Channel>::interface<Interface>();
}
- inline ChannelInterfaceCallStateInterface *callStateInterface(
+ inline Client::ChannelInterfaceCallStateInterface *callStateInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceCallStateInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceCallStateInterface>(check);
}
- inline ChannelInterfaceChatStateInterface *chatStateInterface(
+ inline Client::ChannelInterfaceChatStateInterface *chatStateInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceChatStateInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceChatStateInterface>(check);
}
- inline ChannelInterfaceDTMFInterface *DTMFInterface(
+ inline Client::ChannelInterfaceDTMFInterface *DTMFInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceDTMFInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceDTMFInterface>(check);
}
- inline ChannelInterfaceHoldInterface *holdInterface(
+ inline Client::ChannelInterfaceHoldInterface *holdInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceHoldInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceHoldInterface>(check);
}
- inline ChannelInterfaceMediaSignallingInterface *mediaSignallingInterface(
+ inline Client::ChannelInterfaceMediaSignallingInterface *mediaSignallingInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceMediaSignallingInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceMediaSignallingInterface>(check);
}
- inline ChannelInterfaceMessagesInterface *messagesInterface(
+ inline Client::ChannelInterfaceMessagesInterface *messagesInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceMessagesInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceMessagesInterface>(check);
}
- inline ChannelInterfacePasswordInterface *passwordInterface(
+ inline Client::ChannelInterfacePasswordInterface *passwordInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfacePasswordInterface>(check);
+ return optionalInterface<Client::ChannelInterfacePasswordInterface>(check);
}
- inline DBus::PropertiesInterface *propertiesInterface() const
+ inline Client::DBus::PropertiesInterface *propertiesInterface() const
{
- return optionalInterface<DBus::PropertiesInterface>(BypassInterfaceCheck);
+ return optionalInterface<Client::DBus::PropertiesInterface>(BypassInterfaceCheck);
}
template <class Interface>
@@ -238,40 +236,40 @@ public:
return OptionalInterfaceFactory<Channel>::interface<Interface>();
}
- inline ChannelTypeRoomListInterface *roomListInterface(
+ inline Client::ChannelTypeRoomListInterface *roomListInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return typeInterface<ChannelTypeRoomListInterface>(check);
+ return typeInterface<Client::ChannelTypeRoomListInterface>(check);
}
- inline ChannelTypeStreamedMediaInterface *streamedMediaInterface(
+ inline Client::ChannelTypeStreamedMediaInterface *streamedMediaInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return typeInterface<ChannelTypeStreamedMediaInterface>(check);
+ return typeInterface<Client::ChannelTypeStreamedMediaInterface>(check);
}
- inline ChannelTypeTextInterface *textInterface(
+ inline Client::ChannelTypeTextInterface *textInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return typeInterface<ChannelTypeTextInterface>(check);
+ return typeInterface<Client::ChannelTypeTextInterface>(check);
}
- inline ChannelTypeTubesInterface *tubesInterface(
+ inline Client::ChannelTypeTubesInterface *tubesInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return typeInterface<ChannelTypeTubesInterface>(check);
+ return typeInterface<Client::ChannelTypeTubesInterface>(check);
}
protected:
Channel(const ConnectionPtr &connection,const QString &objectPath,
const QVariantMap &immutableProperties);
- ChannelInterface *baseInterface() const;
+ Client::ChannelInterface *baseInterface() const;
- inline ChannelInterfaceGroupInterface *groupInterface(
+ inline Client::ChannelInterfaceGroupInterface *groupInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ChannelInterfaceGroupInterface>(check);
+ return optionalInterface<Client::ChannelInterfaceGroupInterface>(check);
}
private Q_SLOTS:
@@ -289,7 +287,7 @@ private Q_SLOTS:
void gotAllMembers(QDBusPendingCallWatcher *watcher);
void gotLocalPendingMembersWithInfo(QDBusPendingCallWatcher *watcher);
void gotSelfHandle(QDBusPendingCallWatcher *watcher);
- void gotContacts(Telepathy::Client::PendingOperation *op);
+ void gotContacts(Telepathy::PendingOperation *op);
void onGroupFlagsChanged(uint, uint);
void onMembersChanged(const QString&,
@@ -310,9 +308,8 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
-Q_DECLARE_METATYPE(Telepathy::Client::Channel::GroupMemberChangeDetails);
+Q_DECLARE_METATYPE(Telepathy::Channel::GroupMemberChangeDetails);
#endif
diff --git a/TelepathyQt4/connection-internal.h b/TelepathyQt4/connection-internal.h
index 6d72cfe..d69ec45 100644
--- a/TelepathyQt4/connection-internal.h
+++ b/TelepathyQt4/connection-internal.h
@@ -30,8 +30,6 @@
namespace Telepathy
{
-namespace Client
-{
class Connection::PendingConnect : public PendingReady
{
@@ -42,10 +40,9 @@ public:
private Q_SLOTS:
void onConnectReply(QDBusPendingCallWatcher *);
- void onBecomeReadyReply(Telepathy::Client::PendingOperation *);
+ void onBecomeReadyReply(Telepathy::PendingOperation *);
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/connection-manager-internal.h b/TelepathyQt4/connection-manager-internal.h
index e6036fa..c851dbd 100644
--- a/TelepathyQt4/connection-manager-internal.h
+++ b/TelepathyQt4/connection-manager-internal.h
@@ -31,11 +31,8 @@
namespace Telepathy
{
-namespace Client
-{
class ConnectionManager;
-class ConnectionManagerInterface;
class ReadinessHelper;
struct ConnectionManager::Private
@@ -62,7 +59,7 @@ struct ConnectionManager::Private
QString name;
// Instance of generated interface class
- ConnectionManagerInterface *baseInterface;
+ Client::ConnectionManagerInterface *baseInterface;
ReadinessHelper *readinessHelper;
@@ -93,7 +90,6 @@ private:
QDBusConnection mBus;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/connection-manager.cpp b/TelepathyQt4/connection-manager.cpp
index e988c44..06629ce 100644
--- a/TelepathyQt4/connection-manager.cpp
+++ b/TelepathyQt4/connection-manager.cpp
@@ -61,8 +61,6 @@
namespace Telepathy
{
-namespace Client
-{
ProtocolParameter::ProtocolParameter(const QString &name,
const QDBusSignature &dbusSignature,
@@ -284,7 +282,7 @@ void ConnectionManager::Private::PendingNames::parseResult(const QStringList &na
ConnectionManager::Private::Private(ConnectionManager *parent, const QString &name)
: parent(parent),
name(name),
- baseInterface(new ConnectionManagerInterface(parent->dbusConnection(),
+ baseInterface(new Client::ConnectionManagerInterface(parent->dbusConnection(),
parent->busName(), parent->objectPath(), parent)),
readinessHelper(parent->readinessHelper())
{
@@ -494,7 +492,7 @@ PendingStringList *ConnectionManager::listNames(const QDBusConnection &bus)
* \return A pointer to the existing ConnectionManagerInterface for this
* ConnectionManager.
*/
-ConnectionManagerInterface *ConnectionManager::baseInterface() const
+Client::ConnectionManagerInterface *ConnectionManager::baseInterface() const
{
return mPriv->baseInterface;
}
@@ -542,7 +540,7 @@ void ConnectionManager::Private::introspectMain(ConnectionManager::Private *self
warning() << "Error parsing config file for connection manager"
<< self->name << "- introspecting";
- DBus::PropertiesInterface *properties = self->parent->propertiesInterface();
+ Client::DBus::PropertiesInterface *properties = self->parent->propertiesInterface();
Q_ASSERT(properties != 0);
debug() << "Calling Properties::GetAll(ConnectionManager)";
@@ -678,5 +676,4 @@ void ConnectionManager::gotParameters(QDBusPendingCallWatcher *watcher)
watcher->deleteLater();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/connection-manager.h b/TelepathyQt4/connection-manager.h
index 8eec869..ecba905 100644
--- a/TelepathyQt4/connection-manager.h
+++ b/TelepathyQt4/connection-manager.h
@@ -41,8 +41,6 @@
namespace Telepathy
{
-namespace Client
-{
class PendingConnection;
class PendingReady;
@@ -144,9 +142,9 @@ public:
PendingConnection *requestConnection(const QString &protocol,
const QVariantMap ¶meters);
- inline DBus::PropertiesInterface *propertiesInterface() const
+ inline Client::DBus::PropertiesInterface *propertiesInterface() const
{
- return OptionalInterfaceFactory<ConnectionManager>::interface<DBus::PropertiesInterface>();
+ return OptionalInterfaceFactory<ConnectionManager>::interface<Client::DBus::PropertiesInterface>();
}
static PendingStringList *listNames(const QDBusConnection &bus = QDBusConnection::sessionBus());
@@ -155,7 +153,7 @@ protected:
ConnectionManager(const QString &name);
ConnectionManager(const QDBusConnection &bus, const QString &name);
- ConnectionManagerInterface *baseInterface() const;
+ Client::ConnectionManagerInterface *baseInterface() const;
private Q_SLOTS:
void gotMainProperties(QDBusPendingCallWatcher *);
@@ -171,7 +169,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/connection.cpp b/TelepathyQt4/connection.cpp
index 0fd12ae..0b1cb3d 100644
--- a/TelepathyQt4/connection.cpp
+++ b/TelepathyQt4/connection.cpp
@@ -69,8 +69,6 @@
namespace Telepathy
{
-namespace Client
-{
struct Connection::Private
{
@@ -92,11 +90,11 @@ struct Connection::Private
Connection *parent;
// Instance of generated interface class
- ConnectionInterface *baseInterface;
+ Client::ConnectionInterface *baseInterface;
// Optional interface proxies
- DBus::PropertiesInterface *properties;
- ConnectionInterfaceSimplePresenceInterface *simplePresence;
+ Client::DBus::PropertiesInterface *properties;
+ Client::ConnectionInterfaceSimplePresenceInterface *simplePresence;
ReadinessHelper *readinessHelper;
@@ -155,7 +153,7 @@ struct Connection::Private::HandleContext
Connection::Private::Private(Connection *parent)
: parent(parent),
- baseInterface(new ConnectionInterface(parent->dbusConnection(),
+ baseInterface(new Client::ConnectionInterface(parent->dbusConnection(),
parent->busName(), parent->objectPath(), parent)),
properties(0),
simplePresence(0),
@@ -352,8 +350,8 @@ void Connection::Private::introspectSelfContact(Connection::Private *self)
<< Contact::FeatureAvatarToken
<< Contact::FeatureSimplePresence);
self->parent->connect(contacts,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(gotSelfContact(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(gotSelfContact(Telepathy::PendingOperation *)));
}
void Connection::Private::introspectSelfHandle()
@@ -385,8 +383,8 @@ void Connection::Private::introspectRoster(Connection::Private *self)
QStringList() << ContactManager::ContactListChannel::identifierForType(
(ContactManager::ContactListChannel::Type) i));
self->parent->connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(gotContactListsHandles(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(gotContactListsHandles(Telepathy::PendingOperation*)));
}
}
@@ -408,12 +406,12 @@ void Connection::PendingConnect::onConnectReply(QDBusPendingCallWatcher *watcher
}
else {
connect(qobject_cast<Connection*>(parent())->becomeReady(requestedFeatures()),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onBecomeReadyReply(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onBecomeReadyReply(Telepathy::PendingOperation*)));
}
}
-void Connection::PendingConnect::onBecomeReadyReply(Telepathy::Client::PendingOperation *op)
+void Connection::PendingConnect::onBecomeReadyReply(Telepathy::PendingOperation *op)
{
if (op->isError()) {
setFinishedWithError(op->errorName(), op->errorMessage());
@@ -983,8 +981,8 @@ void Connection::gotContactListsHandles(PendingOperation *op)
mPriv->contactListsChannels[type].handle = handle;
request[QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle")] = handle[0];
connect(ensureChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(gotContactListChannel(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(gotContactListChannel(Telepathy::PendingOperation*)));
}
void Connection::gotContactListChannel(PendingOperation *op)
@@ -1005,7 +1003,7 @@ void Connection::gotContactListChannel(PendingOperation *op)
Q_ASSERT(!mPriv->contactListsChannels[i].channel);
mPriv->contactListsChannels[i].channel = channel;
connect(channel->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
+ SIGNAL(finished(Telepathy::PendingOperation *)),
SLOT(contactListChannelReady()));
}
}
@@ -1030,7 +1028,7 @@ void Connection::contactListChannelReady()
* \return A pointer to the existing ConnectionInterface for this
* Connection.
*/
-ConnectionInterface *Connection::baseInterface() const
+Client::ConnectionInterface *Connection::baseInterface() const
{
return mPriv->baseInterface;
}
@@ -1330,8 +1328,8 @@ PendingContactAttributes *Connection::getContactAttributes(const UIntList &handl
handleContext->types[HandleTypeContact].requestsInFlight++;
}
- ConnectionInterfaceContactsInterface *contactsInterface =
- optionalInterface<ConnectionInterfaceContactsInterface>();
+ Client::ConnectionInterfaceContactsInterface *contactsInterface =
+ optionalInterface<Client::ConnectionInterfaceContactsInterface>();
QDBusPendingCallWatcher *watcher =
new QDBusPendingCallWatcher(contactsInterface->GetContactAttributes(handles, interfaces,
reference));
@@ -1452,5 +1450,4 @@ void Connection::onSelfHandleChanged(uint handle)
}
}
-}
-}
+} // Telepathy
diff --git a/TelepathyQt4/connection.h b/TelepathyQt4/connection.h
index 3bfb7a6..de052c1 100644
--- a/TelepathyQt4/connection.h
+++ b/TelepathyQt4/connection.h
@@ -46,8 +46,6 @@
namespace Telepathy
{
-namespace Client
-{
class Channel;
class Contact;
@@ -113,45 +111,45 @@ public:
return OptionalInterfaceFactory<Connection>::interface<Interface>();
}
- inline ConnectionInterfaceAliasingInterface *aliasingInterface(
+ inline Client::ConnectionInterfaceAliasingInterface *aliasingInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ConnectionInterfaceAliasingInterface>(check);
+ return optionalInterface<Client::ConnectionInterfaceAliasingInterface>(check);
}
- inline ConnectionInterfaceAvatarsInterface *avatarsInterface(
+ inline Client::ConnectionInterfaceAvatarsInterface *avatarsInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ConnectionInterfaceAvatarsInterface>(check);
+ return optionalInterface<Client::ConnectionInterfaceAvatarsInterface>(check);
}
- inline ConnectionInterfaceCapabilitiesInterface *capabilitiesInterface(
+ inline Client::ConnectionInterfaceCapabilitiesInterface *capabilitiesInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ConnectionInterfaceCapabilitiesInterface>(check);
+ return optionalInterface<Client::ConnectionInterfaceCapabilitiesInterface>(check);
}
- inline ConnectionInterfacePresenceInterface *presenceInterface(
+ inline Client::ConnectionInterfacePresenceInterface *presenceInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ConnectionInterfacePresenceInterface>(check);
+ return optionalInterface<Client::ConnectionInterfacePresenceInterface>(check);
}
- inline ConnectionInterfaceSimplePresenceInterface *simplePresenceInterface(
+ inline Client::ConnectionInterfaceSimplePresenceInterface *simplePresenceInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ConnectionInterfaceSimplePresenceInterface>(check);
+ return optionalInterface<Client::ConnectionInterfaceSimplePresenceInterface>(check);
}
- inline ConnectionInterfaceRequestsInterface *requestsInterface(
+ inline Client::ConnectionInterfaceRequestsInterface *requestsInterface(
InterfaceSupportedChecking check = CheckInterfaceSupported) const
{
- return optionalInterface<ConnectionInterfaceRequestsInterface>(check);
+ return optionalInterface<Client::ConnectionInterfaceRequestsInterface>(check);
}
- inline DBus::PropertiesInterface *propertiesInterface() const
+ inline Client::DBus::PropertiesInterface *propertiesInterface() const
{
- return optionalInterface<DBus::PropertiesInterface>(BypassInterfaceCheck);
+ return optionalInterface<Client::DBus::PropertiesInterface>(BypassInterfaceCheck);
}
PendingChannel *createChannel(const QVariantMap &request);
@@ -182,7 +180,7 @@ protected:
Connection(const QDBusConnection &bus, const QString &busName,
const QString &objectPath);
- ConnectionInterface *baseInterface() const;
+ Client::ConnectionInterface *baseInterface() const;
private Q_SLOTS:
void onStatusReady(uint);
@@ -191,10 +189,10 @@ private Q_SLOTS:
void gotInterfaces(QDBusPendingCallWatcher *watcher);
void gotContactAttributeInterfaces(QDBusPendingCallWatcher *watcher);
void gotSimpleStatuses(QDBusPendingCallWatcher *watcher);
- void gotSelfContact(Telepathy::Client::PendingOperation *);
+ void gotSelfContact(Telepathy::PendingOperation *);
void gotSelfHandle(QDBusPendingCallWatcher *watcher);
- void gotContactListsHandles(Telepathy::Client::PendingOperation *);
- void gotContactListChannel(Telepathy::Client::PendingOperation *);
+ void gotContactListsHandles(Telepathy::PendingOperation *);
+ void gotContactListChannel(Telepathy::PendingOperation *);
void contactListChannelReady();
void doReleaseSweep(uint type);
@@ -218,7 +216,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/constants.h b/TelepathyQt4/constants.h
index f27869d..103a24d 100644
--- a/TelepathyQt4/constants.h
+++ b/TelepathyQt4/constants.h
@@ -70,7 +70,7 @@
/**
* The well-known bus name of the Account Manager.
*
- * \see Telepathy::Client::AccountManager
+ * \see Telepathy::AccountManager
*/
#define TELEPATHY_ACCOUNT_MANAGER_BUS_NAME \
"org.freedesktop.Telepathy.AccountManager"
@@ -78,7 +78,7 @@
/**
* The object path of the Account Manager object.
*
- * \see Telepathy::Client::AccountManager
+ * \see Telepathy::AccountManager
*/
#define TELEPATHY_ACCOUNT_MANAGER_OBJECT_PATH \
"/org/freedesktop/Telepathy/AccountManager"
@@ -88,7 +88,7 @@
* "gabble"), the protocol (e.g. "jabber") and an element
* identifying the particular account should be appended.
*
- * \see Telepathy::Client::Account
+ * \see Telepathy::Account
*/
#define TELEPATHY_ACCOUNT_OBJECT_PATH_BASE \
"/org/freedesktop/Telepathy/Account"
diff --git a/TelepathyQt4/contact-manager.cpp b/TelepathyQt4/contact-manager.cpp
index 73a7f40..8e8508f 100644
--- a/TelepathyQt4/contact-manager.cpp
+++ b/TelepathyQt4/contact-manager.cpp
@@ -56,8 +56,6 @@
namespace Telepathy
{
-namespace Client
-{
/**
* \class ContactManager
@@ -759,36 +757,36 @@ void ContactManager::setContactListChannels(
if (type == ContactListChannel::TypeSubscribe) {
method = SLOT(onSubscribeChannelMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &));
} else if (type == ContactListChannel::TypePublish) {
method = SLOT(onPublishChannelMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &));
} else if (type == ContactListChannel::TypeDeny) {
method = SLOT(onDenyChannelMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &));
} else {
continue;
}
connect(channel.data(),
SIGNAL(groupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &)),
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &)),
method);
}
}
@@ -948,5 +946,4 @@ uint ContactManager::ContactListChannel::typeForIdentifier(const QString &identi
return (uint) -1;
}
-}
-}
+} // Telepathy
diff --git a/TelepathyQt4/contact-manager.h b/TelepathyQt4/contact-manager.h
index 9e7025f..7a31734 100644
--- a/TelepathyQt4/contact-manager.h
+++ b/TelepathyQt4/contact-manager.h
@@ -38,8 +38,6 @@
namespace Telepathy
{
-namespace Client
-{
class Connection;
class PendingContacts;
@@ -95,7 +93,7 @@ class ContactManager : public QObject
ContactPtr lookupContactByHandle(uint handle);
Q_SIGNALS:
- void presencePublicationRequested(const Telepathy::Client::Contacts &contacts);
+ void presencePublicationRequested(const Telepathy::Contacts &contacts);
private Q_SLOTS:
void onAliasesChanged(const Telepathy::AliasPairList &);
@@ -103,23 +101,23 @@ class ContactManager : public QObject
void onPresencesChanged(const Telepathy::SimpleContactPresences &);
void onSubscribeChannelMembersChanged(
- const Telepathy::Client::Contacts &groupMembersAdded,
- const Telepathy::Client::Contacts &groupLocalPendingMembersAdded,
- const Telepathy::Client::Contacts &groupRemotePendingMembersAdded,
- const Telepathy::Client::Contacts &groupMembersRemoved,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &details);
+ const Telepathy::Contacts &groupMembersAdded,
+ const Telepathy::Contacts &groupLocalPendingMembersAdded,
+ const Telepathy::Contacts &groupRemotePendingMembersAdded,
+ const Telepathy::Contacts &groupMembersRemoved,
+ const Telepathy::Channel::GroupMemberChangeDetails &details);
void onPublishChannelMembersChanged(
- const Telepathy::Client::Contacts &groupMembersAdded,
- const Telepathy::Client::Contacts &groupLocalPendingMembersAdded,
- const Telepathy::Client::Contacts &groupRemotePendingMembersAdded,
- const Telepathy::Client::Contacts &groupMembersRemoved,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &details);
+ const Telepathy::Contacts &groupMembersAdded,
+ const Telepathy::Contacts &groupLocalPendingMembersAdded,
+ const Telepathy::Contacts &groupRemotePendingMembersAdded,
+ const Telepathy::Contacts &groupMembersRemoved,
+ const Telepathy::Channel::GroupMemberChangeDetails &details);
void onDenyChannelMembersChanged(
- const Telepathy::Client::Contacts &groupMembersAdded,
- const Telepathy::Client::Contacts &groupLocalPendingMembersAdded,
- const Telepathy::Client::Contacts &groupRemotePendingMembersAdded,
- const Telepathy::Client::Contacts &groupMembersRemoved,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &details);
+ const Telepathy::Contacts &groupMembersAdded,
+ const Telepathy::Contacts &groupLocalPendingMembersAdded,
+ const Telepathy::Contacts &groupRemotePendingMembersAdded,
+ const Telepathy::Contacts &groupMembersRemoved,
+ const Telepathy::Channel::GroupMemberChangeDetails &details);
private:
struct ContactListChannel
@@ -169,7 +167,6 @@ class ContactManager : public QObject
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/contact.cpp b/TelepathyQt4/contact.cpp
index 0a0274f..f90d202 100644
--- a/TelepathyQt4/contact.cpp
+++ b/TelepathyQt4/contact.cpp
@@ -31,8 +31,6 @@
namespace Telepathy
{
-namespace Client
-{
struct Contact::Private
{
@@ -357,5 +355,4 @@ void Contact::setBlocked(bool value)
emit blockStatusChanged(value);
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/contact.h b/TelepathyQt4/contact.h
index a5706be..0fce4fc 100644
--- a/TelepathyQt4/contact.h
+++ b/TelepathyQt4/contact.h
@@ -35,8 +35,6 @@
namespace Telepathy
{
-namespace Client
-{
class ContactManager;
class PendingOperation;
@@ -95,13 +93,13 @@ Q_SIGNALS:
void avatarTokenChanged(const QString &avatarToken);
void simplePresenceChanged(const QString &status, uint type, const QString &presenceMessage);
- void subscriptionStateChanged(Telepathy::Client::Contact::PresenceState state);
- void publishStateChanged(Telepathy::Client::Contact::PresenceState state);
+ void subscriptionStateChanged(Telepathy::Contact::PresenceState state);
+ void publishStateChanged(Telepathy::Contact::PresenceState state);
void blockStatusChanged(bool blocked);
// TODO: consider how the Renaming interface should work and map to Contacts
// I guess it would be something like:
- // void renamedTo(Telepathy::Client::ContactPtr)
+ // void renamedTo(Telepathy::ContactPtr)
// with that contact getting the same features requested as the current one. Or would we rather
// want to signal that change right away with a handle?
@@ -135,7 +133,6 @@ inline uint qHash(const ContactPtr &contact)
return qHash(contact.data());
}
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/dbus-proxy.cpp b/TelepathyQt4/dbus-proxy.cpp
index 294e320..9b35d93 100644
--- a/TelepathyQt4/dbus-proxy.cpp
+++ b/TelepathyQt4/dbus-proxy.cpp
@@ -35,8 +35,6 @@
namespace Telepathy
{
-namespace Client
-{
// ==== DBusProxy ======================================================
@@ -200,7 +198,7 @@ QString DBusProxy::invalidationMessage() const
}
/**
- * \fn void DBusProxy::invalidated (Telepathy::Client::DBusProxy *proxy,
+ * \fn void DBusProxy::invalidated (Telepathy::DBusProxy *proxy,
* const QString &errorName, const QString &errorMessage)
*
* Emitted when this object is no longer usable.
@@ -351,5 +349,4 @@ StatelessDBusProxy::~StatelessDBusProxy()
{
}
-}
-}
+} // Telepathy
diff --git a/TelepathyQt4/dbus-proxy.h b/TelepathyQt4/dbus-proxy.h
index 2a84b0c..1267bd9 100644
--- a/TelepathyQt4/dbus-proxy.h
+++ b/TelepathyQt4/dbus-proxy.h
@@ -33,8 +33,6 @@ class QDBusError;
namespace Telepathy
{
-namespace Client
-{
class DBusProxy : public QObject
{
@@ -67,7 +65,7 @@ protected:
void invalidate(const QDBusError &error);
Q_SIGNALS:
- void invalidated(Telepathy::Client::DBusProxy *proxy,
+ void invalidated(Telepathy::DBusProxy *proxy,
const QString &errorName, const QString &errorMessage);
private Q_SLOTS:
@@ -118,6 +116,5 @@ private:
};
}
-}
#endif
diff --git a/TelepathyQt4/debug.cpp b/TelepathyQt4/debug.cpp
index 567bbe8..f35db99 100644
--- a/TelepathyQt4/debug.cpp
+++ b/TelepathyQt4/debug.cpp
@@ -86,4 +86,4 @@ void enableWarnings(bool enable)
#endif /* #ifdef ENABLE_DEBUG */
-} /* namespace Telepathy */
+} // Telepathy
diff --git a/TelepathyQt4/feature.cpp b/TelepathyQt4/feature.cpp
index 5c70a6a..ece331c 100644
--- a/TelepathyQt4/feature.cpp
+++ b/TelepathyQt4/feature.cpp
@@ -23,8 +23,6 @@
namespace Telepathy
{
-namespace Client
-{
struct Feature::Private : public QSharedData
{
@@ -61,5 +59,4 @@ bool Feature::isCritical() const
return mPriv->critical;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/feature.h b/TelepathyQt4/feature.h
index 3334a64..c304ecd 100644
--- a/TelepathyQt4/feature.h
+++ b/TelepathyQt4/feature.h
@@ -33,8 +33,6 @@
namespace Telepathy
{
-namespace Client
-{
class Feature : public QPair<QString, uint>
{
@@ -66,7 +64,6 @@ inline Features operator|(const Feature &feature1, const Feature &feature2)
return Features() << feature1 << feature2;
}
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/file-transfer.cpp b/TelepathyQt4/file-transfer.cpp
index 5732dca..591762d 100644
--- a/TelepathyQt4/file-transfer.cpp
+++ b/TelepathyQt4/file-transfer.cpp
@@ -27,8 +27,6 @@
namespace Telepathy
{
-namespace Client
-{
struct FileTransfer::Private
{
@@ -91,5 +89,4 @@ FileTransfer::~FileTransfer()
delete mPriv;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/file-transfer.h b/TelepathyQt4/file-transfer.h
index 5881a90..46aa7de 100644
--- a/TelepathyQt4/file-transfer.h
+++ b/TelepathyQt4/file-transfer.h
@@ -29,8 +29,6 @@
namespace Telepathy
{
-namespace Client
-{
class FileTransfer : public Channel
{
@@ -53,7 +51,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/key-file.cpp b/TelepathyQt4/key-file.cpp
index 40b1cc1..49e27f6 100644
--- a/TelepathyQt4/key-file.cpp
+++ b/TelepathyQt4/key-file.cpp
@@ -552,4 +552,4 @@ QStringList KeyFile::valueAsStringList(const QString &key) const
return mPriv->valueAsStringList(key);
}
-}
+} // Telepathy
diff --git a/TelepathyQt4/manager-file.cpp b/TelepathyQt4/manager-file.cpp
index 0fcd5da..afd2645 100644
--- a/TelepathyQt4/manager-file.cpp
+++ b/TelepathyQt4/manager-file.cpp
@@ -360,4 +360,4 @@ QVariant::Type ManagerFile::variantTypeFromDBusSignature(const QString &signatur
return type;
}
-}
+} // Telepathy
diff --git a/TelepathyQt4/message.cpp b/TelepathyQt4/message.cpp
index f71cb74..b654d06 100644
--- a/TelepathyQt4/message.cpp
+++ b/TelepathyQt4/message.cpp
@@ -31,8 +31,6 @@
namespace Telepathy
{
-namespace Client
-{
class Message::Private : public QSharedData
{
@@ -568,5 +566,4 @@ void ReceivedMessage::setSender(const ContactPtr &sender)
mPriv->sender = sender;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/message.h b/TelepathyQt4/message.h
index c8c801e..bd4197f 100644
--- a/TelepathyQt4/message.h
+++ b/TelepathyQt4/message.h
@@ -36,8 +36,7 @@ class QDateTime;
namespace Telepathy
{
-namespace Client
-{
+
class Contact;
class TextChannel;
@@ -120,7 +119,6 @@ private:
void setSender(const ContactPtr &sender);
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/optional-interface-factory.cpp b/TelepathyQt4/optional-interface-factory.cpp
index def4500..2e8e058 100644
--- a/TelepathyQt4/optional-interface-factory.cpp
+++ b/TelepathyQt4/optional-interface-factory.cpp
@@ -30,8 +30,6 @@
namespace Telepathy
{
-namespace Client
-{
struct OptionalInterfaceCache::Private
{
@@ -81,5 +79,4 @@ void OptionalInterfaceCache::cache(AbstractInterface *interface) const
mPriv->interfaces[name] = interface;
}
-}
-}
+} // Telepathy
diff --git a/TelepathyQt4/optional-interface-factory.h b/TelepathyQt4/optional-interface-factory.h
index cba7ae6..4f0a9e5 100644
--- a/TelepathyQt4/optional-interface-factory.h
+++ b/TelepathyQt4/optional-interface-factory.h
@@ -42,8 +42,6 @@
namespace Telepathy
{
-namespace Client
-{
class AbstractInterface;
@@ -154,7 +152,6 @@ template <typename DBusProxySubclass> class OptionalInterfaceFactory
}
};
-}
-}
+} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-account.cpp b/TelepathyQt4/pending-account.cpp
index 4248df1..9f99197 100644
--- a/TelepathyQt4/pending-account.cpp
+++ b/TelepathyQt4/pending-account.cpp
@@ -44,8 +44,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingAccount::Private
{
@@ -173,5 +171,4 @@ void PendingAccount::onCallFinished(QDBusPendingCallWatcher *watcher)
watcher->deleteLater();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-account.h b/TelepathyQt4/pending-account.h
index 3c60c53..7d2eafd 100644
--- a/TelepathyQt4/pending-account.h
+++ b/TelepathyQt4/pending-account.h
@@ -36,8 +36,6 @@ class QDBusPendingCallWatcher;
namespace Telepathy
{
-namespace Client
-{
class AccountManager;
@@ -69,7 +67,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-channel.cpp b/TelepathyQt4/pending-channel.cpp
index d1e3663..8b813d6 100644
--- a/TelepathyQt4/pending-channel.cpp
+++ b/TelepathyQt4/pending-channel.cpp
@@ -46,8 +46,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingChannel::Private
{
@@ -358,5 +356,4 @@ void PendingChannel::onCallEnsureChannelFinished(QDBusPendingCallWatcher *watche
watcher->deleteLater();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-channel.h b/TelepathyQt4/pending-channel.h
index e16085c..bcf8033 100644
--- a/TelepathyQt4/pending-channel.h
+++ b/TelepathyQt4/pending-channel.h
@@ -36,8 +36,6 @@
namespace Telepathy
{
-namespace Client
-{
class Connection;
@@ -82,7 +80,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-connection.cpp b/TelepathyQt4/pending-connection.cpp
index 7951b85..9dd2a02 100644
--- a/TelepathyQt4/pending-connection.cpp
+++ b/TelepathyQt4/pending-connection.cpp
@@ -45,8 +45,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingConnection::Private
{
@@ -196,5 +194,4 @@ void PendingConnection::onCallFinished(QDBusPendingCallWatcher *watcher)
watcher->deleteLater();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-connection.h b/TelepathyQt4/pending-connection.h
index c295ad3..1c14c90 100644
--- a/TelepathyQt4/pending-connection.h
+++ b/TelepathyQt4/pending-connection.h
@@ -36,8 +36,6 @@ class QDBusPendingCallWatcher;
namespace Telepathy
{
-namespace Client
-{
class ConnectionManager;
@@ -70,7 +68,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-contact-attributes.cpp b/TelepathyQt4/pending-contact-attributes.cpp
index 10e4c38..2a80b8a 100644
--- a/TelepathyQt4/pending-contact-attributes.cpp
+++ b/TelepathyQt4/pending-contact-attributes.cpp
@@ -49,8 +49,6 @@
namespace Telepathy
{
-namespace Client
-{
/**
* \class PendingContactAttributes
@@ -241,5 +239,4 @@ void PendingContactAttributes::failImmediately(const QString &error, const QStri
setFinishedWithError(error, errorMessage);
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-contact-attributes.h b/TelepathyQt4/pending-contact-attributes.h
index f74721c..3816d3d 100644
--- a/TelepathyQt4/pending-contact-attributes.h
+++ b/TelepathyQt4/pending-contact-attributes.h
@@ -22,13 +22,9 @@
#ifndef _TelepathyQt4_cli_pending_contact_attributes_h_HEADER_GUARD_
#define _TelepathyQt4_cli_pending_contact_attributes_h_HEADER_GUARD_
-namespace Telepathy
-{
-namespace Client
-{
-class PendingContactAttributes;
-}
-}
+#ifndef IN_TELEPATHY_QT4_HEADER
+#error IN_TELEPATHY_QT4_HEADER
+#endif
#include <TelepathyQt4/PendingOperation>
#include <TelepathyQt4/Types>
@@ -37,8 +33,6 @@ class PendingContactAttributes;
namespace Telepathy
{
-namespace Client
-{
class ReferencedHandles;
@@ -74,7 +68,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-contacts.cpp b/TelepathyQt4/pending-contacts.cpp
index 3065af0..eb692a5 100644
--- a/TelepathyQt4/pending-contacts.cpp
+++ b/TelepathyQt4/pending-contacts.cpp
@@ -32,8 +32,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingContacts::Private
{
@@ -258,8 +256,8 @@ void PendingContacts::onRequestHandlesFinished(PendingOperation *operation)
mPriv->nested = manager()->contactsForHandles(pendingHandles->handles(), features());
connect(mPriv->nested,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onNestedFinished(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onNestedFinished(Telepathy::PendingOperation*)));
}
void PendingContacts::onReferenceHandlesFinished(PendingOperation *operation)
@@ -369,16 +367,16 @@ PendingContacts::PendingContacts(ContactManager *manager,
interfaces, true);
connect(attributes,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onAttributesFinished(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onAttributesFinished(Telepathy::PendingOperation*)));
} else {
debug() << " Falling back to inspect contact handles";
// fallback to just create the contacts
PendingHandles *handles = conn->referenceHandles(HandleTypeContact,
otherContacts.toList());
connect(handles,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onReferenceHandlesFinished(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onReferenceHandlesFinished(Telepathy::PendingOperation*)));
}
} else {
allAttributesFetched();
@@ -393,8 +391,8 @@ PendingContacts::PendingContacts(ContactManager *manager,
PendingHandles *handles = conn->requestHandles(HandleTypeContact, identifiers);
connect(handles,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onRequestHandlesFinished(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onRequestHandlesFinished(Telepathy::PendingOperation*)));
}
PendingContacts::PendingContacts(ContactManager *manager,
@@ -408,8 +406,8 @@ PendingContacts::PendingContacts(ContactManager *manager,
mPriv->nested = manager->contactsForHandles(handles, features);
connect(mPriv->nested,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onNestedFinished(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onNestedFinished(Telepathy::PendingOperation*)));
}
void PendingContacts::allAttributesFetched()
@@ -423,5 +421,4 @@ void PendingContacts::allAttributesFetched()
setFinished();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-contacts.h b/TelepathyQt4/pending-contacts.h
index 41ccdb5..5d2797c 100644
--- a/TelepathyQt4/pending-contacts.h
+++ b/TelepathyQt4/pending-contacts.h
@@ -39,8 +39,6 @@
namespace Telepathy
{
-namespace Client
-{
class ContactManager;
@@ -69,10 +67,10 @@ public:
QHash<QString, QPair<QString, QString> > invalidIdentifiers() const;
private Q_SLOTS:
- void onAttributesFinished(Telepathy::Client::PendingOperation *);
- void onRequestHandlesFinished(Telepathy::Client::PendingOperation *);
- void onReferenceHandlesFinished(Telepathy::Client::PendingOperation *);
- void onNestedFinished(Telepathy::Client::PendingOperation *);
+ void onAttributesFinished(Telepathy::PendingOperation *);
+ void onRequestHandlesFinished(Telepathy::PendingOperation *);
+ void onReferenceHandlesFinished(Telepathy::PendingOperation *);
+ void onNestedFinished(Telepathy::PendingOperation *);
void onInspectHandlesFinished(QDBusPendingCallWatcher *);
private:
@@ -96,7 +94,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-handles.cpp b/TelepathyQt4/pending-handles.cpp
index b9857bf..5634b83 100644
--- a/TelepathyQt4/pending-handles.cpp
+++ b/TelepathyQt4/pending-handles.cpp
@@ -41,8 +41,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingHandles::Private
{
@@ -495,5 +493,4 @@ void PendingHandles::onHoldHandlesFallbackFinished(QDBusPendingCallWatcher *watc
watcher->deleteLater();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-handles.h b/TelepathyQt4/pending-handles.h
index 09075e0..52d7d24 100644
--- a/TelepathyQt4/pending-handles.h
+++ b/TelepathyQt4/pending-handles.h
@@ -38,8 +38,6 @@
namespace Telepathy
{
-namespace Client
-{
class PendingHandles;
class ReferencedHandles;
@@ -90,7 +88,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-operation.cpp b/TelepathyQt4/pending-operation.cpp
index 2ef8576..e8bc5b7 100644
--- a/TelepathyQt4/pending-operation.cpp
+++ b/TelepathyQt4/pending-operation.cpp
@@ -36,9 +36,6 @@
namespace Telepathy
{
-namespace Client
-{
-
struct PendingOperation::Private
{
@@ -188,6 +185,4 @@ void PendingVoidMethodCall::watcherFinished(QDBusPendingCallWatcher* watcher)
}
}
-
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-operation.h b/TelepathyQt4/pending-operation.h
index 15a58ba..a0baa8d 100644
--- a/TelepathyQt4/pending-operation.h
+++ b/TelepathyQt4/pending-operation.h
@@ -34,8 +34,6 @@ class QDBusPendingCallWatcher;
namespace Telepathy
{
-namespace Client
-{
/**
* Abstract base class for pending asynchronous operations.
@@ -133,7 +131,7 @@ Q_SIGNALS:
* \param operation This operation object, from which further information
* may be obtained
*/
- void finished(Telepathy::Client::PendingOperation* operation);
+ void finished(Telepathy::PendingOperation* operation);
protected:
/**
@@ -174,8 +172,6 @@ private:
Private *mPriv;
};
-
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-ready.cpp b/TelepathyQt4/pending-ready.cpp
index a76b224..fa077bf 100644
--- a/TelepathyQt4/pending-ready.cpp
+++ b/TelepathyQt4/pending-ready.cpp
@@ -38,8 +38,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingReady::Private
{
@@ -103,5 +101,4 @@ Features PendingReady::requestedFeatures() const
return mPriv->requestedFeatures;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-ready.h b/TelepathyQt4/pending-ready.h
index 2936fd7..3c9f22a 100644
--- a/TelepathyQt4/pending-ready.h
+++ b/TelepathyQt4/pending-ready.h
@@ -33,8 +33,6 @@
namespace Telepathy
{
-namespace Client
-{
class PendingReady: public PendingOperation
{
@@ -58,7 +56,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/pending-string-list.cpp b/TelepathyQt4/pending-string-list.cpp
index 1b710f2..5817473 100644
--- a/TelepathyQt4/pending-string-list.cpp
+++ b/TelepathyQt4/pending-string-list.cpp
@@ -28,8 +28,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingStringList::Private
{
@@ -65,5 +63,4 @@ void PendingStringList::setResult(const QStringList &result)
mPriv->result = result;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/pending-string-list.h b/TelepathyQt4/pending-string-list.h
index 1e5797b..32f5e82 100644
--- a/TelepathyQt4/pending-string-list.h
+++ b/TelepathyQt4/pending-string-list.h
@@ -32,8 +32,6 @@
namespace Telepathy
{
-namespace Client
-{
class PendingStringList : public PendingOperation
{
@@ -56,7 +54,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/properties.cpp b/TelepathyQt4/properties.cpp
index 609d3db..63ef058 100644
--- a/TelepathyQt4/properties.cpp
+++ b/TelepathyQt4/properties.cpp
@@ -21,5 +21,5 @@
#include <TelepathyQt4/Properties>
-#include <TelepathyQt4/_gen/cli-properties-body.hpp>
-#include <TelepathyQt4/_gen/cli-properties.moc.hpp>
+#include "TelepathyQt4/_gen/cli-properties-body.hpp"
+#include "TelepathyQt4/_gen/cli-properties.moc.hpp"
diff --git a/TelepathyQt4/readiness-helper.cpp b/TelepathyQt4/readiness-helper.cpp
index aebf54c..e4a835c 100644
--- a/TelepathyQt4/readiness-helper.cpp
+++ b/TelepathyQt4/readiness-helper.cpp
@@ -34,8 +34,6 @@
namespace Telepathy
{
-namespace Client
-{
struct ReadinessHelper::Private
{
@@ -99,8 +97,8 @@ ReadinessHelper::Private::Private(
if (proxy) {
parent->connect(proxy,
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
- SLOT(onProxyInvalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)));
+ SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
+ SLOT(onProxyInvalidated(Telepathy::DBusProxy *, const QString &, const QString &)));
}
debug() << "ReadinessHelper: supportedStatuses =" << supportedStatuses;
@@ -283,9 +281,9 @@ void ReadinessHelper::Private::abortOperations(const QString &errorName,
{
foreach (PendingReady *operation, pendingOperations) {
parent->disconnect(operation,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
parent,
- SLOT(onOperationFinished(Telepathy::Client::PendingOperation*)));
+ SLOT(onOperationFinished(Telepathy::PendingOperation*)));
parent->disconnect(operation,
SIGNAL(destroyed(QObject*)),
parent,
@@ -480,8 +478,8 @@ PendingReady *ReadinessHelper::becomeReady(const Features &requestedFeatures)
operation = new PendingReady(requestedFeatures, mPriv->object, this);
connect(operation,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onOperationFinished(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onOperationFinished(Telepathy::PendingOperation*)));
connect(operation,
SIGNAL(destroyed(QObject*)),
SLOT(onOperationDestroyed(QObject*)));
@@ -536,5 +534,5 @@ void ReadinessHelper::onOperationDestroyed(QObject *obj)
{
mPriv->pendingOperations.removeOne(qobject_cast<PendingReady*>(obj));
}
-}
-}
+
+} // Telepathy
diff --git a/TelepathyQt4/readiness-helper.h b/TelepathyQt4/readiness-helper.h
index 78b4c17..2e088b8 100644
--- a/TelepathyQt4/readiness-helper.h
+++ b/TelepathyQt4/readiness-helper.h
@@ -36,8 +36,6 @@ class QDBusError;
namespace Telepathy
{
-namespace Client
-{
class DBusProxy;
class PendingOperation;
@@ -121,9 +119,9 @@ Q_SIGNALS:
private Q_SLOTS:
void iterateIntrospection();
- void onProxyInvalidated(Telepathy::Client::DBusProxy *proxy,
+ void onProxyInvalidated(Telepathy::DBusProxy *proxy,
const QString &errorName, const QString &errorMessage);
- void onOperationFinished(Telepathy::Client::PendingOperation *op);
+ void onOperationFinished(Telepathy::PendingOperation *op);
void onOperationDestroyed(QObject *obj);
private:
@@ -132,7 +130,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/ready-object.cpp b/TelepathyQt4/ready-object.cpp
index 14c7965..9b25fae 100644
--- a/TelepathyQt4/ready-object.cpp
+++ b/TelepathyQt4/ready-object.cpp
@@ -28,8 +28,6 @@
namespace Telepathy
{
-namespace Client
-{
struct ReadyObject::Private
{
@@ -141,5 +139,4 @@ ReadinessHelper *ReadyObject::readinessHelper() const
return mPriv->readinessHelper;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/ready-object.h b/TelepathyQt4/ready-object.h
index 74460ae..f23e140 100644
--- a/TelepathyQt4/ready-object.h
+++ b/TelepathyQt4/ready-object.h
@@ -32,8 +32,6 @@
namespace Telepathy
{
-namespace Client
-{
class DBusProxy;
class PendingReady;
@@ -63,7 +61,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/referenced-handles.cpp b/TelepathyQt4/referenced-handles.cpp
index 6f75192..67b2f92 100644
--- a/TelepathyQt4/referenced-handles.cpp
+++ b/TelepathyQt4/referenced-handles.cpp
@@ -30,8 +30,6 @@
namespace Telepathy
{
-namespace Client
-{
struct ReferencedHandles::Private : public QSharedData
{
@@ -299,5 +297,4 @@ ReferencedHandles::ReferencedHandles(const ConnectionPtr &connection,
{
}
-}
-}
+} // Telepathy
diff --git a/TelepathyQt4/referenced-handles.h b/TelepathyQt4/referenced-handles.h
index 021720f..9a93988 100644
--- a/TelepathyQt4/referenced-handles.h
+++ b/TelepathyQt4/referenced-handles.h
@@ -57,8 +57,7 @@
namespace Telepathy
{
-namespace Client
-{
+
class Connection;
/**
@@ -288,7 +287,6 @@ class ReferencedHandles
typedef QListIterator<uint> ReferencedHandlesIterator;
-}
-}
+} // Telepathy
#endif
diff --git a/TelepathyQt4/room-list.cpp b/TelepathyQt4/room-list.cpp
index 2c4adaa..6b1de67 100644
--- a/TelepathyQt4/room-list.cpp
+++ b/TelepathyQt4/room-list.cpp
@@ -27,8 +27,6 @@
namespace Telepathy
{
-namespace Client
-{
struct RoomList::Private
{
@@ -90,5 +88,4 @@ RoomList::~RoomList()
delete mPriv;
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/room-list.h b/TelepathyQt4/room-list.h
index 9f85771..0253449 100644
--- a/TelepathyQt4/room-list.h
+++ b/TelepathyQt4/room-list.h
@@ -29,8 +29,6 @@
namespace Telepathy
{
-namespace Client
-{
class RoomList : public Channel
{
@@ -53,7 +51,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/simple-pending-operations.h b/TelepathyQt4/simple-pending-operations.h
index 209752e..8e0e6ef 100644
--- a/TelepathyQt4/simple-pending-operations.h
+++ b/TelepathyQt4/simple-pending-operations.h
@@ -32,9 +32,6 @@
namespace Telepathy
{
-namespace Client
-{
-
/**
* A %PendingOperation that is always successful.
@@ -52,7 +49,6 @@ public:
}
};
-
/**
* A %PendingOperation that always fails with the error passed to the
* constructor.
@@ -77,7 +73,6 @@ public:
}
};
-
/**
* Generic subclass of %PendingOperation representing a pending D-Bus method
* call that does not return anything (or returns a result that is not
@@ -111,8 +106,6 @@ private:
Private *mPriv;
};
-
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/streamed-media-channel.cpp b/TelepathyQt4/streamed-media-channel.cpp
index 1b8e99f..df07b6d 100644
--- a/TelepathyQt4/streamed-media-channel.cpp
+++ b/TelepathyQt4/streamed-media-channel.cpp
@@ -34,8 +34,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingMediaStreams::Private
{
@@ -125,11 +123,11 @@ void PendingMediaStreams::gotStreams(QDBusPendingCallWatcher *watcher)
}
mPriv->streams.append(stream);
connect(channel.data(),
- SIGNAL(streamRemoved(Telepathy::Client::MediaStreamPtr)),
- SLOT(onStreamRemoved(Telepathy::Client::MediaStreamPtr)));
+ SIGNAL(streamRemoved(Telepathy::MediaStreamPtr)),
+ SLOT(onStreamRemoved(Telepathy::MediaStreamPtr)));
connect(stream->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onStreamReady(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onStreamReady(Telepathy::PendingOperation*)));
}
watcher->deleteLater();
@@ -225,8 +223,8 @@ void MediaStream::Private::introspectContact(MediaStream::Private *self)
ContactManager *contactManager = chan->connection()->contactManager();
self->parent->connect(
contactManager->contactsForHandles(UIntList() << self->contactHandle),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(gotContact(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(gotContact(Telepathy::PendingOperation *)));
}
const Feature MediaStream::FeatureContact = Feature(MediaStream::staticMetaObject.className(), 0);
@@ -474,7 +472,7 @@ StreamedMediaChannel::Private::~Private()
void StreamedMediaChannel::Private::introspectStreams(StreamedMediaChannel::Private *self)
{
StreamedMediaChannel *parent = self->parent;
- ChannelTypeStreamedMediaInterface *streamedMediaInterface =
+ Client::ChannelTypeStreamedMediaInterface *streamedMediaInterface =
parent->streamedMediaInterface();
parent->connect(streamedMediaInterface,
@@ -846,8 +844,8 @@ void StreamedMediaChannel::addStream(const MediaStreamPtr &stream)
{
mPriv->incompleteStreams.insert(stream->id(), stream);
connect(stream->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onStreamReady(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onStreamReady(Telepathy::PendingOperation*)));
}
MediaStreamPtr StreamedMediaChannel::lookupStreamById(uint streamId)
@@ -860,5 +858,4 @@ MediaStreamPtr StreamedMediaChannel::lookupStreamById(uint streamId)
return MediaStreamPtr();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/streamed-media-channel.h b/TelepathyQt4/streamed-media-channel.h
index bc12783..9ef5411 100644
--- a/TelepathyQt4/streamed-media-channel.h
+++ b/TelepathyQt4/streamed-media-channel.h
@@ -32,8 +32,6 @@
namespace Telepathy
{
-namespace Client
-{
class StreamedMediaChannel;
@@ -51,8 +49,8 @@ public:
private Q_SLOTS:
void gotStreams(QDBusPendingCallWatcher *);
- void onStreamRemoved(Telepathy::Client::MediaStreamPtr);
- void onStreamReady(Telepathy::Client::PendingOperation *);
+ void onStreamRemoved(Telepathy::MediaStreamPtr);
+ void onStreamReady(Telepathy::PendingOperation *);
private:
friend class StreamedMediaChannel;
@@ -97,7 +95,7 @@ public:
bool send, bool receive);
private Q_SLOTS:
- void gotContact(Telepathy::Client::PendingOperation *op);
+ void gotContact(Telepathy::PendingOperation *op);
private:
friend class PendingMediaStreams;
@@ -153,14 +151,14 @@ public:
QList<Telepathy::MediaStreamType> types);
Q_SIGNALS:
- void streamAdded(const Telepathy::Client::MediaStreamPtr &stream);
- void streamRemoved(const Telepathy::Client::MediaStreamPtr &stream);
- void streamDirectionChanged(const Telepathy::Client::MediaStreamPtr &stream,
+ void streamAdded(const Telepathy::MediaStreamPtr &stream);
+ void streamRemoved(const Telepathy::MediaStreamPtr &stream);
+ void streamDirectionChanged(const Telepathy::MediaStreamPtr &stream,
Telepathy::MediaStreamDirection direction,
Telepathy::MediaStreamPendingSend pendingSend);
- void streamStateChanged(const Telepathy::Client::MediaStreamPtr &stream,
+ void streamStateChanged(const Telepathy::MediaStreamPtr &stream,
Telepathy::MediaStreamState);
- void streamError(const Telepathy::Client::MediaStreamPtr &stream,
+ void streamError(const Telepathy::MediaStreamPtr &stream,
Telepathy::MediaStreamError errorCode,
const QString &errorMessage);
@@ -170,7 +168,7 @@ protected:
private Q_SLOTS:
void gotStreams(QDBusPendingCallWatcher *);
- void onStreamReady(Telepathy::Client::PendingOperation *);
+ void onStreamReady(Telepathy::PendingOperation *);
void onStreamAdded(uint, uint, uint);
void onStreamRemoved(uint);
void onStreamDirectionChanged(uint, uint, uint);
@@ -188,7 +186,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/text-channel.cpp b/TelepathyQt4/text-channel.cpp
index 95ff88f..fd86650 100644
--- a/TelepathyQt4/text-channel.cpp
+++ b/TelepathyQt4/text-channel.cpp
@@ -36,8 +36,6 @@
namespace Telepathy
{
-namespace Client
-{
struct PendingSendMessage::Private
{
@@ -350,7 +348,7 @@ const Feature TextChannel::FeatureMessageCapabilities = Feature(TextChannel::sta
const Feature TextChannel::FeatureMessageSentSignal = Feature(TextChannel::staticMetaObject.className(), 2);
/**
- * \fn void TextChannel::messageSent(const Telepathy::Client::Message &message,
+ * \fn void TextChannel::messageSent(const Telepathy::Message &message,
* Telepathy::MessageSendingFlags flags,
* const QString &sentMessageToken)
*
@@ -372,7 +370,7 @@ const Feature TextChannel::FeatureMessageSentSignal = Feature(TextChannel::stati
*/
/**
- * \fn void TextChannel::messageReceived(const Telepathy::Client::ReceivedMessage &message)
+ * \fn void TextChannel::messageReceived(const Telepathy::ReceivedMessage &message)
*
* Emitted when a message is added to messageQueue(), if the
* FeatureMessageQueue Feature has been enabled.
@@ -383,7 +381,7 @@ const Feature TextChannel::FeatureMessageSentSignal = Feature(TextChannel::stati
/**
* \fn void TextChannel::pendingMessageRemoved(
- * const Telepathy::Client::ReceivedMessage &message)
+ * const Telepathy::ReceivedMessage &message)
*
* Emitted when a message is removed from messageQueue(), if the
* FeatureMessageQueue Feature has been enabled. See messageQueue() for the
@@ -743,8 +741,8 @@ void TextChannel::processQueue()
connect(connection()->contactManager()->contactsForHandles(
contactsRequired.toList()),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onContactsFinished(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onContactsFinished(Telepathy::PendingOperation *)));
mPriv->awaitingContacts |= contactsRequired;
}
@@ -1004,5 +1002,4 @@ void TextChannel::gotPendingMessages(QDBusPendingCallWatcher *watcher)
watcher->deleteLater();
}
-} // Telepathy::Client
} // Telepathy
diff --git a/TelepathyQt4/text-channel.h b/TelepathyQt4/text-channel.h
index be34088..2196af7 100644
--- a/TelepathyQt4/text-channel.h
+++ b/TelepathyQt4/text-channel.h
@@ -30,8 +30,6 @@
namespace Telepathy
{
-namespace Client
-{
class PendingReadyChannel;
class Message;
@@ -107,21 +105,21 @@ public Q_SLOTS:
Q_SIGNALS:
// FeatureMessageSentSignal
- void messageSent(const Telepathy::Client::Message &message,
+ void messageSent(const Telepathy::Message &message,
Telepathy::MessageSendingFlags flags,
const QString &sentMessageToken);
// FeatureMessageQueue
- void messageReceived(const Telepathy::Client::ReceivedMessage &message);
+ void messageReceived(const Telepathy::ReceivedMessage &message);
void pendingMessageRemoved(
- const Telepathy::Client::ReceivedMessage &message);
+ const Telepathy::ReceivedMessage &message);
protected:
TextChannel(const ConnectionPtr &connection, const QString &objectPath,
const QVariantMap &immutableProperties);
private Q_SLOTS:
- void onContactsFinished(Telepathy::Client::PendingOperation *);
+ void onContactsFinished(Telepathy::PendingOperation *);
void onAcknowledgePendingMessagesReply(QDBusPendingCallWatcher *);
void onMessageSent(const Telepathy::MessagePartList &, uint,
@@ -144,7 +142,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/TelepathyQt4/types.cpp b/TelepathyQt4/types.cpp
index c2eeabe..618af9b 100644
--- a/TelepathyQt4/types.cpp
+++ b/TelepathyQt4/types.cpp
@@ -21,5 +21,4 @@
#include <TelepathyQt4/Types>
-#define IN_TELEPATHY_QT4_HEADER
-#include "_gen/types-body.hpp"
+#include "TelepathyQt4/_gen/types-body.hpp"
diff --git a/TelepathyQt4/types.h b/TelepathyQt4/types.h
index 772ff98..61901db 100644
--- a/TelepathyQt4/types.h
+++ b/TelepathyQt4/types.h
@@ -32,8 +32,6 @@
namespace Telepathy
{
-namespace Client
-{
class Account;
class AccountManager;
@@ -57,7 +55,6 @@ typedef SharedPtr<MediaStream> MediaStreamPtr;
typedef SharedPtr<StreamedMediaChannel> StreamedMediaChannelPtr;
typedef SharedPtr<TextChannel> TextChannelPtr;
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/examples/accounts/account-item.cpp b/examples/accounts/account-item.cpp
index c43ec3b..ef3403e 100644
--- a/examples/accounts/account-item.cpp
+++ b/examples/accounts/account-item.cpp
@@ -28,17 +28,17 @@
#include <QComboBox>
#include <QTableWidget>
-AccountItem::AccountItem(Telepathy::Client::AccountManagerPtr am,
+AccountItem::AccountItem(Telepathy::AccountManagerPtr am,
const QString &objectPath, QTableWidget *table, int row, QObject *parent)
: QObject(parent),
- mAcc(Telepathy::Client::Account::create(am->dbusConnection(),
+ mAcc(Telepathy::Account::create(am->dbusConnection(),
am->busName(), objectPath)),
mTable(table),
mRow(row)
{
connect(mAcc->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onReady(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onReady(Telepathy::PendingOperation *)));
}
AccountItem::~AccountItem()
@@ -61,11 +61,11 @@ void AccountItem::setupGui()
mTable->setItem(mRow, ColumnConnection, new QTableWidgetItem(mAcc->connectionObjectPath()));
}
-void AccountItem::onReady(Telepathy::Client::PendingOperation *op)
+void AccountItem::onReady(Telepathy::PendingOperation *op)
{
setupGui();
- Telepathy::Client::Account *acc = mAcc.data();
+ Telepathy::Account *acc = mAcc.data();
connect(acc,
SIGNAL(validityChanged(bool)),
SLOT(onValidityChanged(bool)));
diff --git a/examples/accounts/account-item.h b/examples/accounts/account-item.h
index 4438cf6..bad8b1b 100644
--- a/examples/accounts/account-item.h
+++ b/examples/accounts/account-item.h
@@ -28,11 +28,9 @@
#include <QString>
namespace Telepathy {
-namespace Client {
class AccountManager;
class PendingOperation;
}
-}
class QTableWidget;
@@ -58,14 +56,14 @@ public:
};
Q_ENUMS(Columns)
- AccountItem(Telepathy::Client::AccountManagerPtr am, const QString &objectPath,
+ AccountItem(Telepathy::AccountManagerPtr am, const QString &objectPath,
QTableWidget *table, int row, QObject *parent = 0);
virtual ~AccountItem();
int row() const { return mRow; }
private Q_SLOTS:
- void onReady(Telepathy::Client::PendingOperation *);
+ void onReady(Telepathy::PendingOperation *);
void onValidityChanged(bool);
void onStateChanged(bool);
void onDisplayNameChanged(const QString &);
@@ -81,7 +79,7 @@ private Q_SLOTS:
private:
void setupGui();
- Telepathy::Client::AccountPtr mAcc;
+ Telepathy::AccountPtr mAcc;
QTableWidget *mTable;
int mRow;
};
diff --git a/examples/accounts/accounts-window.cpp b/examples/accounts/accounts-window.cpp
index a1e1ed3..6bb0d33 100644
--- a/examples/accounts/accounts-window.cpp
+++ b/examples/accounts/accounts-window.cpp
@@ -41,10 +41,10 @@ AccountsWindow::AccountsWindow(QWidget *parent)
{
setupGui();
- mAM = Telepathy::Client::AccountManager::create();
+ mAM = Telepathy::AccountManager::create();
connect(mAM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onAMReady(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onAMReady(Telepathy::PendingOperation *)));
connect(mAM.data(),
SIGNAL(accountCreated(const QString &)),
SLOT(onAccountCreated(const QString &)));
@@ -78,7 +78,7 @@ void AccountsWindow::setupGui()
setCentralWidget(mTable);
}
-void AccountsWindow::onAMReady(Telepathy::Client::PendingOperation *op)
+void AccountsWindow::onAMReady(Telepathy::PendingOperation *op)
{
mTable->setRowCount(mAM->validAccountPaths().count());
diff --git a/examples/accounts/accounts-window.h b/examples/accounts/accounts-window.h
index b6b0660..5a98715 100644
--- a/examples/accounts/accounts-window.h
+++ b/examples/accounts/accounts-window.h
@@ -26,10 +26,8 @@
#include <TelepathyQt4/Types>
namespace Telepathy {
-namespace Client {
class PendingOperation;
}
-}
class QTableWidget;
class QTableWidgetItem;
@@ -43,13 +41,13 @@ public:
virtual ~AccountsWindow();
private Q_SLOTS:
- void onAMReady(Telepathy::Client::PendingOperation *);
+ void onAMReady(Telepathy::PendingOperation *);
void onAccountCreated(const QString &);
private:
void setupGui();
- Telepathy::Client::AccountManagerPtr mAM;
+ Telepathy::AccountManagerPtr mAM;
QTableWidget *mTable;
};
diff --git a/examples/call/call-handler.cpp b/examples/call/call-handler.cpp
index e016357..825c64c 100644
--- a/examples/call/call-handler.cpp
+++ b/examples/call/call-handler.cpp
@@ -36,7 +36,7 @@
#include <QDebug>
#include <QMessageBox>
-using namespace Telepathy::Client;
+using namespace Telepathy;
CallHandler::CallHandler(QObject *parent)
: QObject(parent)
@@ -62,16 +62,16 @@ void CallHandler::addOutgoingCall(const ContactPtr &contact)
ConnectionPtr conn = contact->manager()->connection();
connect(conn->ensureChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onOutgoingChannelCreated(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onOutgoingChannelCreated(Telepathy::PendingOperation*)));
}
void CallHandler::addIncomingCall(const StreamedMediaChannelPtr &chan)
{
mChannels.append(chan);
connect(chan->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onIncomingChannelReady(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onIncomingChannelReady(Telepathy::PendingOperation*)));
}
void CallHandler::onOutgoingChannelCreated(PendingOperation *op)
@@ -92,8 +92,8 @@ void CallHandler::onOutgoingChannelCreated(PendingOperation *op)
pc->objectPath(), pc->immutableProperties());
mChannels.append(chan);
connect(chan->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onOutgoingChannelReady(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onOutgoingChannelReady(Telepathy::PendingOperation*)));
}
void CallHandler::onOutgoingChannelReady(PendingOperation *op)
diff --git a/examples/call/call-handler.h b/examples/call/call-handler.h
index ff75ad7..6973cec 100644
--- a/examples/call/call-handler.h
+++ b/examples/call/call-handler.h
@@ -28,11 +28,9 @@
#include <TelepathyQt4/Contact>
namespace Telepathy {
-namespace Client {
class PendingOperation;
class StreamedMediaChannel;
}
-}
class CallWidget;
@@ -44,17 +42,17 @@ public:
CallHandler(QObject *parent = 0);
virtual ~CallHandler();
- void addOutgoingCall(const Telepathy::Client::ContactPtr &contact);
- void addIncomingCall(const Telepathy::Client::StreamedMediaChannelPtr &chan);
+ void addOutgoingCall(const Telepathy::ContactPtr &contact);
+ void addIncomingCall(const Telepathy::StreamedMediaChannelPtr &chan);
private Q_SLOTS:
- void onOutgoingChannelCreated(Telepathy::Client::PendingOperation *);
- void onOutgoingChannelReady(Telepathy::Client::PendingOperation *);
- void onIncomingChannelReady(Telepathy::Client::PendingOperation *);
+ void onOutgoingChannelCreated(Telepathy::PendingOperation *);
+ void onOutgoingChannelReady(Telepathy::PendingOperation *);
+ void onIncomingChannelReady(Telepathy::PendingOperation *);
void onCallTerminated(QObject *);
private:
- QList<Telepathy::Client::StreamedMediaChannelPtr> mChannels;
+ QList<Telepathy::StreamedMediaChannelPtr> mChannels;
QList<CallWidget *> mCalls;
};
diff --git a/examples/call/call-roster-widget.cpp b/examples/call/call-roster-widget.cpp
index 06ebb92..2747b7e 100644
--- a/examples/call/call-roster-widget.cpp
+++ b/examples/call/call-roster-widget.cpp
@@ -37,7 +37,7 @@
#include <QAction>
#include <QDebug>
-using namespace Telepathy::Client;
+using namespace Telepathy;
CallRosterWidget::CallRosterWidget(CallHandler *callHandler, QWidget *parent)
: RosterWidget(parent),
diff --git a/examples/call/call-roster-widget.h b/examples/call/call-roster-widget.h
index 419a340..40d9dd4 100644
--- a/examples/call/call-roster-widget.h
+++ b/examples/call/call-roster-widget.h
@@ -27,10 +27,8 @@
#include <examples/roster/roster-widget.h>
namespace Telepathy {
-namespace Client {
class Channel;
}
-}
class CallHandler;
class CallWidget;
@@ -45,7 +43,7 @@ public:
protected:
virtual RosterItem *createItemForContact(
- const Telepathy::Client::ContactPtr &contact,
+ const Telepathy::ContactPtr &contact,
bool &exists);
virtual void updateActions(RosterItem *item);
diff --git a/examples/call/call-widget.cpp b/examples/call/call-widget.cpp
index f947ded..ce4dcdd 100644
--- a/examples/call/call-widget.cpp
+++ b/examples/call/call-widget.cpp
@@ -39,7 +39,7 @@
#include <QStatusBar>
#include <QVBoxLayout>
-using namespace Telepathy::Client;
+using namespace Telepathy;
CallWidget::CallWidget(const StreamedMediaChannelPtr &chan,
const ContactPtr &contact,
@@ -58,15 +58,15 @@ CallWidget::CallWidget(const StreamedMediaChannelPtr &chan,
setupGui();
connect(mChan->becomeReady(StreamedMediaChannel::FeatureStreams),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onChannelReady(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onChannelReady(Telepathy::PendingOperation*)));
connect(mChan.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
- SLOT(onChannelInvalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)));
+ SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
+ SLOT(onChannelInvalidated(Telepathy::DBusProxy *, const QString &, const QString &)));
connect(mTfChan,
- SIGNAL(statusChanged(Telepathy::Client::FarsightChannel::Status)),
- SLOT(onTfChannelStatusChanged(Telepathy::Client::FarsightChannel::Status)));
+ SIGNAL(statusChanged(Telepathy::FarsightChannel::Status)),
+ SLOT(onTfChannelStatusChanged(Telepathy::FarsightChannel::Status)));
}
CallWidget::~CallWidget()
@@ -178,22 +178,22 @@ void CallWidget::onChannelReady(PendingOperation *op)
}
connect(mChan.data(),
- SIGNAL(streamAdded(const Telepathy::Client::MediaStreamPtr &)),
- SLOT(onStreamAdded(const Telepathy::Client::MediaStreamPtr &)));
+ SIGNAL(streamAdded(const Telepathy::MediaStreamPtr &)),
+ SLOT(onStreamAdded(const Telepathy::MediaStreamPtr &)));
connect(mChan.data(),
- SIGNAL(streamRemoved(const Telepathy::Client::MediaStreamPtr &)),
- SLOT(onStreamRemoved(const Telepathy::Client::MediaStreamPtr &)));
+ SIGNAL(streamRemoved(const Telepathy::MediaStreamPtr &)),
+ SLOT(onStreamRemoved(const Telepathy::MediaStreamPtr &)));
connect(mChan.data(),
- SIGNAL(streamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ SIGNAL(streamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend)),
- SLOT(onStreamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ SLOT(onStreamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend)));
connect(mChan.data(),
- SIGNAL(streamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ SIGNAL(streamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState)),
- SLOT(onStreamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ SLOT(onStreamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState)));
MediaStreams streams = mChan->streams();
@@ -389,8 +389,8 @@ void CallWidget::onBtnSendAudioToggled(bool checked)
qDebug() << "CallWidget::onBtnSendAudioToggled: creating audio stream";
mPmsAudio = mChan->requestStream(mContact, Telepathy::MediaStreamTypeAudio);
connect(mPmsAudio,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onStreamCreated(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onStreamCreated(Telepathy::PendingOperation*)));
} else {
updateStreamDirection(stream);
}
@@ -408,8 +408,8 @@ void CallWidget::onBtnSendVideoToggled(bool checked)
qDebug() << "CallWidget::onBtnSendVideoToggled: creating video stream";
mPmsVideo = mChan->requestStream(mContact, Telepathy::MediaStreamTypeVideo);
connect(mPmsVideo,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(onStreamCreated(Telepathy::Client::PendingOperation*)));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(onStreamCreated(Telepathy::PendingOperation*)));
} else {
updateStreamDirection(stream);
}
@@ -470,12 +470,12 @@ void CallWidget::callEnded(const QString &message)
{
mStatusBar->showMessage(message);
disconnect(mChan.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
+ SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
this,
- SLOT(onChannelInvalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)));
+ SLOT(onChannelInvalidated(Telepathy::DBusProxy *, const QString &, const QString &)));
disconnect(mTfChan,
- SIGNAL(statusChanged(Telepathy::Client::FarsightChannel::Status)),
+ SIGNAL(statusChanged(Telepathy::FarsightChannel::Status)),
this,
- SLOT(onTfChannelStatusChanged(Telepathy::Client::FarsightChannel::Status)));
+ SLOT(onTfChannelStatusChanged(Telepathy::FarsightChannel::Status)));
setEnabled(false);
}
diff --git a/examples/call/call-widget.h b/examples/call/call-widget.h
index 0cd929e..74a13e7 100644
--- a/examples/call/call-widget.h
+++ b/examples/call/call-widget.h
@@ -32,13 +32,11 @@
#include "farsight-channel.h"
namespace Telepathy {
-namespace Client {
class DBusProxy;
class MediaStream;
class PendingMediaStreams;
class PendingOperation;
}
-}
class QLabel;
class QPushButton;
@@ -49,27 +47,27 @@ class CallWidget : public QWidget
Q_OBJECT
public:
- CallWidget(const Telepathy::Client::StreamedMediaChannelPtr &channel,
- const Telepathy::Client::ContactPtr &contact,
+ CallWidget(const Telepathy::StreamedMediaChannelPtr &channel,
+ const Telepathy::ContactPtr &contact,
QWidget *parent = 0);
virtual ~CallWidget();
- Telepathy::Client::StreamedMediaChannelPtr channel() const { return mChan; }
- Telepathy::Client::ContactPtr contact() const { return mContact; }
+ Telepathy::StreamedMediaChannelPtr channel() const { return mChan; }
+ Telepathy::ContactPtr contact() const { return mContact; }
private Q_SLOTS:
- void onChannelReady(Telepathy::Client::PendingOperation *);
- void onChannelInvalidated(Telepathy::Client::DBusProxy *,
+ void onChannelReady(Telepathy::PendingOperation *);
+ void onChannelInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &);
- void onStreamCreated(Telepathy::Client::PendingOperation *);
- void onStreamAdded(const Telepathy::Client::MediaStreamPtr &);
- void onStreamRemoved(const Telepathy::Client::MediaStreamPtr &);
- void onStreamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ void onStreamCreated(Telepathy::PendingOperation *);
+ void onStreamAdded(const Telepathy::MediaStreamPtr &);
+ void onStreamRemoved(const Telepathy::MediaStreamPtr &);
+ void onStreamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend);
- void onStreamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ void onStreamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState);
- void onTfChannelStatusChanged(Telepathy::Client::FarsightChannel::Status);
+ void onTfChannelStatusChanged(Telepathy::FarsightChannel::Status);
void onBtnHangupClicked();
void onBtnSendAudioToggled(bool);
@@ -79,17 +77,17 @@ private:
void createActions();
void setupGui();
- Telepathy::Client::MediaStreamPtr streamForType(Telepathy::MediaStreamType type) const;
- void updateStreamDirection(const Telepathy::Client::MediaStreamPtr &stream);
+ Telepathy::MediaStreamPtr streamForType(Telepathy::MediaStreamType type) const;
+ void updateStreamDirection(const Telepathy::MediaStreamPtr &stream);
void callEnded(const QString &message);
- Telepathy::Client::StreamedMediaChannelPtr mChan;
- Telepathy::Client::ContactPtr mContact;
- Telepathy::Client::FarsightChannel *mTfChan;
+ Telepathy::StreamedMediaChannelPtr mChan;
+ Telepathy::ContactPtr mContact;
+ Telepathy::FarsightChannel *mTfChan;
- Telepathy::Client::PendingMediaStreams *mPmsAudio;
- Telepathy::Client::PendingMediaStreams *mPmsVideo;
+ Telepathy::PendingMediaStreams *mPmsAudio;
+ Telepathy::PendingMediaStreams *mPmsVideo;
QPushButton *mBtnHangup;
QPushButton *mBtnSendAudio;
diff --git a/examples/call/call-window.cpp b/examples/call/call-window.cpp
index b997f08..715ad84 100644
--- a/examples/call/call-window.cpp
+++ b/examples/call/call-window.cpp
@@ -35,7 +35,7 @@
#include <QDebug>
-using namespace Telepathy::Client;
+using namespace Telepathy;
CallWindow::CallWindow(const QString &username, const QString &password,
QWidget *parent)
@@ -47,8 +47,8 @@ CallWindow::CallWindow(const QString &username, const QString &password,
mCM = ConnectionManager::create("gabble");
connect(mCM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onCMReady(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onCMReady(Telepathy::PendingOperation *)));
mCallHandler = new CallHandler(this);
@@ -70,7 +70,7 @@ void CallWindow::setupGui()
setCentralWidget(mRoster);
}
-void CallWindow::onCMReady(Telepathy::Client::PendingOperation *op)
+void CallWindow::onCMReady(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "CM cannot become ready";
@@ -83,11 +83,11 @@ void CallWindow::onCMReady(Telepathy::Client::PendingOperation *op)
params.insert("password", QVariant(mPassword));
PendingConnection *pconn = mCM->requestConnection("jabber", params);
connect(pconn,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onConnectionCreated(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onConnectionCreated(Telepathy::PendingOperation *)));
}
-void CallWindow::onConnectionCreated(Telepathy::Client::PendingOperation *op)
+void CallWindow::onConnectionCreated(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "Unable to create connection";
@@ -100,14 +100,14 @@ void CallWindow::onConnectionCreated(Telepathy::Client::PendingOperation *op)
ConnectionPtr conn = pconn->connection();
mConn = conn;
connect(conn->requestConnect(Connection::FeatureSelfContact),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onConnectionConnected(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onConnectionConnected(Telepathy::PendingOperation *)));
connect(conn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
- SLOT(onConnectionInvalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)));
+ SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
+ SLOT(onConnectionInvalidated(Telepathy::DBusProxy *, const QString &, const QString &)));
}
-void CallWindow::onConnectionConnected(Telepathy::Client::PendingOperation *op)
+void CallWindow::onConnectionConnected(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "Connection cannot become connected";
diff --git a/examples/call/call-window.h b/examples/call/call-window.h
index 191b6ce..fd5a344 100644
--- a/examples/call/call-window.h
+++ b/examples/call/call-window.h
@@ -28,12 +28,10 @@
#include <TelepathyQt4/Types>
namespace Telepathy {
-namespace Client {
class ConnectionManager;
class DBusProxy;
class PendingOperation;
}
-}
class CallHandler;
class CallRosterWidget;
@@ -48,18 +46,18 @@ public:
virtual ~CallWindow();
private Q_SLOTS:
- void onCMReady(Telepathy::Client::PendingOperation *);
- void onConnectionCreated(Telepathy::Client::PendingOperation *);
- void onConnectionConnected(Telepathy::Client::PendingOperation *);
- void onConnectionInvalidated(Telepathy::Client::DBusProxy *,
+ void onCMReady(Telepathy::PendingOperation *);
+ void onConnectionCreated(Telepathy::PendingOperation *);
+ void onConnectionConnected(Telepathy::PendingOperation *);
+ void onConnectionInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &);
void onNewChannels(const Telepathy::ChannelDetailsList &);
private:
void setupGui();
- Telepathy::Client::ConnectionManagerPtr mCM;
- Telepathy::Client::ConnectionPtr mConn;
+ Telepathy::ConnectionManagerPtr mCM;
+ Telepathy::ConnectionPtr mConn;
QString mUsername;
QString mPassword;
CallHandler *mCallHandler;
diff --git a/examples/call/farsight-channel.cpp b/examples/call/farsight-channel.cpp
index b69d15a..eded9a0 100644
--- a/examples/call/farsight-channel.cpp
+++ b/examples/call/farsight-channel.cpp
@@ -34,7 +34,6 @@
#include <TelepathyQt4/StreamedMediaChannel>
namespace Telepathy {
-namespace Client {
struct FarsightChannel::Private
{
@@ -346,5 +345,4 @@ VideoWidget *FarsightChannel::videoWidget() const
return mPriv->videoOutput;
}
-}
-}
+} // Telepathy
diff --git a/examples/call/farsight-channel.h b/examples/call/farsight-channel.h
index 68ac88e..f054e46 100644
--- a/examples/call/farsight-channel.h
+++ b/examples/call/farsight-channel.h
@@ -30,7 +30,6 @@
#include <telepathy-farsight/channel.h>
namespace Telepathy {
-namespace Client {
class Connection;
class VideoWidget;
@@ -58,7 +57,7 @@ public:
// TODO add a way to change input and output devices
Q_SIGNALS:
- void statusChanged(Telepathy::Client::FarsightChannel::Status status);
+ void statusChanged(Telepathy::FarsightChannel::Status status);
private:
struct Private;
@@ -66,9 +65,8 @@ private:
Private *mPriv;
};
-}
-}
+} // Telepathy
-Q_DECLARE_METATYPE(Telepathy::Client::FarsightChannel::Status)
+Q_DECLARE_METATYPE(Telepathy::FarsightChannel::Status)
#endif
diff --git a/examples/call/main.cpp b/examples/call/main.cpp
index 1bec37c..4a156dc 100644
--- a/examples/call/main.cpp
+++ b/examples/call/main.cpp
@@ -28,7 +28,7 @@ int main(int argc, char **argv)
Telepathy::registerTypes();
Telepathy::enableDebug(true);
Telepathy::enableWarnings(true);
- qRegisterMetaType<Telepathy::Client::FarsightChannel::Status>();
+ qRegisterMetaType<Telepathy::FarsightChannel::Status>();
CallWindow w(argv[1], argv[2]);
w.show();
diff --git a/examples/call/video-widget.cpp b/examples/call/video-widget.cpp
index a39eff5..d3726cc 100644
--- a/examples/call/video-widget.cpp
+++ b/examples/call/video-widget.cpp
@@ -33,7 +33,6 @@
extern void qt_x11_set_global_double_buffer(bool);
namespace Telepathy {
-namespace Client {
struct VideoWidget::Private {
Private(VideoWidget *parent, GstBus *bus);
@@ -163,5 +162,4 @@ void VideoWidget::windowExposed()
}
}
-}
-}
+} // Telepathy
diff --git a/examples/call/video-widget.h b/examples/call/video-widget.h
index 3fd8c99..2824318 100644
--- a/examples/call/video-widget.h
+++ b/examples/call/video-widget.h
@@ -27,7 +27,6 @@
#include <gst/gst.h>
namespace Telepathy {
-namespace Client {
class VideoWidget : public QWidget
{
@@ -52,7 +51,6 @@ private:
Private *mPriv;
};
-} // Telepathy::Client
} // Telepathy
#endif
diff --git a/examples/extensions/Makefile.am b/examples/extensions/Makefile.am
index b72a493..8e0c433 100644
--- a/examples/extensions/Makefile.am
+++ b/examples/extensions/Makefile.am
@@ -2,8 +2,8 @@
# Typically this would be in a top-level extensions/ directory.
# In this example we build an optional interface for Telepathy Connections,
-# so we specify Telepathy::Client::Connection as the main interface for the
-# generated proxies with "--mainiface=Telepathy::Client::Connection'. The
+# so we specify Telepathy::Client::ConnectionInterface as the main interface for the
+# generated proxies with "--mainiface=Telepathy::Client::ConnectionInterface'. The
# generated proxies will have a convenience constructors for associating the
# proxy with the same remote object an instance of the main interface class
# is associated with. We could instead have made an optional interface for any
diff --git a/examples/roster/roster-item.cpp b/examples/roster/roster-item.cpp
index f1e855b..0e7ad88 100644
--- a/examples/roster/roster-item.cpp
+++ b/examples/roster/roster-item.cpp
@@ -21,7 +21,7 @@
#include "roster-item.h"
#include "_gen/roster-item.moc.hpp"
-using namespace Telepathy::Client;
+using namespace Telepathy;
RosterItem::RosterItem(const ContactPtr &contact,
QListWidget *parent)
@@ -35,10 +35,10 @@ RosterItem::RosterItem(const ContactPtr &contact,
SIGNAL(simplePresenceChanged(const QString &, uint, const QString &)),
SLOT(onContactChanged()));
connect(contact.data(),
- SIGNAL(subscriptionStateChanged(Telepathy::Client::Contact::PresenceState)),
+ SIGNAL(subscriptionStateChanged(Telepathy::Contact::PresenceState)),
SLOT(onContactChanged()));
connect(contact.data(),
- SIGNAL(publishStateChanged(Telepathy::Client::Contact::PresenceState)),
+ SIGNAL(publishStateChanged(Telepathy::Contact::PresenceState)),
SLOT(onContactChanged()));
connect(contact.data(),
SIGNAL(blockStatusChanged(bool)),
diff --git a/examples/roster/roster-item.h b/examples/roster/roster-item.h
index 48d5a4a..54af79a 100644
--- a/examples/roster/roster-item.h
+++ b/examples/roster/roster-item.h
@@ -32,11 +32,11 @@ class RosterItem : public QObject, public QListWidgetItem
Q_OBJECT
public:
- RosterItem(const Telepathy::Client::ContactPtr &contact,
+ RosterItem(const Telepathy::ContactPtr &contact,
QListWidget *parent = 0);
~RosterItem();
- Telepathy::Client::ContactPtr contact() const { return mContact; }
+ Telepathy::ContactPtr contact() const { return mContact; }
Q_SIGNALS:
void changed();
@@ -45,7 +45,7 @@ private Q_SLOTS:
void onContactChanged();
private:
- Telepathy::Client::ContactPtr mContact;
+ Telepathy::ContactPtr mContact;
};
#endif
diff --git a/examples/roster/roster-widget.cpp b/examples/roster/roster-widget.cpp
index 6a01291..a4a5809 100644
--- a/examples/roster/roster-widget.cpp
+++ b/examples/roster/roster-widget.cpp
@@ -44,7 +44,7 @@
#include <QPushButton>
#include <QVBoxLayout>
-using namespace Telepathy::Client;
+using namespace Telepathy;
RosterWidget::RosterWidget(QWidget *parent)
: QWidget(parent)
@@ -63,8 +63,8 @@ void RosterWidget::addConnection(const ConnectionPtr &conn)
{
mConns.append(conn);
connect(conn->becomeReady(Connection::FeatureRoster),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onConnectionReady(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onConnectionReady(Telepathy::PendingOperation *)));
}
void RosterWidget::removeConnection(const ConnectionPtr &conn)
@@ -177,7 +177,7 @@ RosterItem *RosterWidget::createItemForContact(const ContactPtr &contact,
return new RosterItem(contact, mList);
}
-void RosterWidget::onConnectionReady(Telepathy::Client::PendingOperation *op)
+void RosterWidget::onConnectionReady(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "Connection cannot become ready";
@@ -187,8 +187,8 @@ void RosterWidget::onConnectionReady(Telepathy::Client::PendingOperation *op)
PendingReady *pr = qobject_cast<PendingReady *>(op);
ConnectionPtr conn = ConnectionPtr(qobject_cast<Connection *>(pr->object()));
connect(conn->contactManager(),
- SIGNAL(presencePublicationRequested(const Telepathy::Client::Contacts &)),
- SLOT(onPresencePublicationRequested(const Telepathy::Client::Contacts &)));
+ SIGNAL(presencePublicationRequested(const Telepathy::Contacts &)),
+ SLOT(onPresencePublicationRequested(const Telepathy::Contacts &)));
qDebug() << "Connection ready";
RosterItem *item;
@@ -236,8 +236,8 @@ void RosterWidget::onAddButtonClicked()
PendingContacts *pcontacts = mConns.first()->contactManager()->contactsForIdentifiers(
QStringList() << username);
connect(pcontacts,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onContactRetrieved(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onContactRetrieved(Telepathy::PendingOperation *)));
}
void RosterWidget::onAuthActionTriggered(bool checked)
@@ -303,7 +303,7 @@ void RosterWidget::onBlockActionTriggered(bool checked)
item->contact()->block(checked);
}
-void RosterWidget::onContactRetrieved(Telepathy::Client::PendingOperation *op)
+void RosterWidget::onContactRetrieved(Telepathy::PendingOperation *op)
{
PendingContacts *pcontacts = qobject_cast<PendingContacts *>(op);
QList<ContactPtr> contacts = pcontacts->contacts();
diff --git a/examples/roster/roster-widget.h b/examples/roster/roster-widget.h
index 80bc456..361d30b 100644
--- a/examples/roster/roster-widget.h
+++ b/examples/roster/roster-widget.h
@@ -27,11 +27,9 @@
#include <TelepathyQt4/Connection>
namespace Telepathy {
-namespace Client {
class Connection;
class PendingOperation;
}
-}
class QAction;
class QDialog;
@@ -50,35 +48,35 @@ public:
RosterWidget(QWidget *parent = 0);
virtual ~RosterWidget();
- QList<Telepathy::Client::ConnectionPtr> connections() const { return mConns; }
- void addConnection(const Telepathy::Client::ConnectionPtr &conn);
- void removeConnection(const Telepathy::Client::ConnectionPtr &conn);
+ QList<Telepathy::ConnectionPtr> connections() const { return mConns; }
+ void addConnection(const Telepathy::ConnectionPtr &conn);
+ void removeConnection(const Telepathy::ConnectionPtr &conn);
QListWidget *listWidget() const { return mList; }
protected:
virtual RosterItem *createItemForContact(
- const Telepathy::Client::ContactPtr &contact,
+ const Telepathy::ContactPtr &contact,
bool &exists);
virtual void updateActions(RosterItem *item) { }
private Q_SLOTS:
- void onConnectionReady(Telepathy::Client::PendingOperation *);
- void onPresencePublicationRequested(const Telepathy::Client::Contacts &);
+ void onConnectionReady(Telepathy::PendingOperation *);
+ void onPresencePublicationRequested(const Telepathy::Contacts &);
void onItemSelectionChanged();
void onAddButtonClicked();
void onAuthActionTriggered(bool);
void onDenyActionTriggered(bool);
void onRemoveActionTriggered(bool);
void onBlockActionTriggered(bool);
- void onContactRetrieved(Telepathy::Client::PendingOperation *op);
+ void onContactRetrieved(Telepathy::PendingOperation *op);
void updateActions();
private:
void createActions();
void setupGui();
- QList<Telepathy::Client::ConnectionPtr> mConns;
+ QList<Telepathy::ConnectionPtr> mConns;
QAction *mAuthAction;
QAction *mRemoveAction;
QAction *mDenyAction;
diff --git a/examples/roster/roster-window.cpp b/examples/roster/roster-window.cpp
index f719306..1c0430f 100644
--- a/examples/roster/roster-window.cpp
+++ b/examples/roster/roster-window.cpp
@@ -31,7 +31,7 @@
#include <QDebug>
-using namespace Telepathy::Client;
+using namespace Telepathy;
RosterWindow::RosterWindow(const QString &username, const QString &password,
QWidget *parent)
@@ -45,8 +45,8 @@ RosterWindow::RosterWindow(const QString &username, const QString &password,
mCM = ConnectionManager::create("gabble");
connect(mCM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onCMReady(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onCMReady(Telepathy::PendingOperation *)));
resize(240, 320);
}
@@ -64,7 +64,7 @@ void RosterWindow::setupGui()
setCentralWidget(mRoster);
}
-void RosterWindow::onCMReady(Telepathy::Client::PendingOperation *op)
+void RosterWindow::onCMReady(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "CM cannot become ready";
@@ -77,11 +77,11 @@ void RosterWindow::onCMReady(Telepathy::Client::PendingOperation *op)
params.insert("password", QVariant(mPassword));
PendingConnection *pconn = mCM->requestConnection("jabber", params);
connect(pconn,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onConnectionCreated(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onConnectionCreated(Telepathy::PendingOperation *)));
}
-void RosterWindow::onConnectionCreated(Telepathy::Client::PendingOperation *op)
+void RosterWindow::onConnectionCreated(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "Unable to create connection";
@@ -94,14 +94,14 @@ void RosterWindow::onConnectionCreated(Telepathy::Client::PendingOperation *op)
ConnectionPtr conn = pconn->connection();
mConns.append(conn);
connect(conn->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(onConnectionConnected(Telepathy::Client::PendingOperation *)));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(onConnectionConnected(Telepathy::PendingOperation *)));
connect(conn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
- SLOT(onConnectionInvalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)));
+ SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
+ SLOT(onConnectionInvalidated(Telepathy::DBusProxy *, const QString &, const QString &)));
}
-void RosterWindow::onConnectionConnected(Telepathy::Client::PendingOperation *op)
+void RosterWindow::onConnectionConnected(Telepathy::PendingOperation *op)
{
if (op->isError()) {
qWarning() << "Connection cannot become connected";
diff --git a/examples/roster/roster-window.h b/examples/roster/roster-window.h
index 5ba5124..96743f2 100644
--- a/examples/roster/roster-window.h
+++ b/examples/roster/roster-window.h
@@ -27,12 +27,10 @@
#include <TelepathyQt4/Connection>
namespace Telepathy {
-namespace Client {
class ConnectionManager;
class DBusProxy;
class PendingOperation;
}
-}
class RosterWidget;
@@ -46,17 +44,17 @@ public:
virtual ~RosterWindow();
private Q_SLOTS:
- void onCMReady(Telepathy::Client::PendingOperation *);
- void onConnectionCreated(Telepathy::Client::PendingOperation *);
- void onConnectionConnected(Telepathy::Client::PendingOperation *);
- void onConnectionInvalidated(Telepathy::Client::DBusProxy *,
+ void onCMReady(Telepathy::PendingOperation *);
+ void onConnectionCreated(Telepathy::PendingOperation *);
+ void onConnectionConnected(Telepathy::PendingOperation *);
+ void onConnectionInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &);
private:
void setupGui();
- Telepathy::Client::ConnectionManagerPtr mCM;
- QList<Telepathy::Client::ConnectionPtr> mConns;
+ Telepathy::ConnectionManagerPtr mCM;
+ QList<Telepathy::ConnectionPtr> mConns;
QString mUsername;
QString mPassword;
RosterWidget *mRoster;
diff --git a/tests/dbus/account-basics.cpp b/tests/dbus/account-basics.cpp
index 464af92..7d65aec 100644
--- a/tests/dbus/account-basics.cpp
+++ b/tests/dbus/account-basics.cpp
@@ -12,7 +12,7 @@
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestAccountBasics : public Test
{
@@ -63,8 +63,8 @@ void TestAccountBasics::init()
void TestAccountBasics::testBasics()
{
QVERIFY(connect(mAM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mAM->isReady(), true);
@@ -73,8 +73,8 @@ void TestAccountBasics::testBasics()
PendingAccount *pacc = mAM->createAccount("foo",
"bar", "foobar", parameters);
QVERIFY(connect(pacc,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(pacc->account());
@@ -92,15 +92,15 @@ void TestAccountBasics::testBasics()
AccountPtr acc = mAM->accountForPath(
"/org/freedesktop/Telepathy/Account/foo/bar/Account0");
QVERIFY(connect(acc->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(acc->displayName(), QString("foobar (account 0)"));
QVERIFY(connect(acc->becomeReady(Account::FeatureAvatar),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(acc->isReady(Account::FeatureAvatar), true);
@@ -112,13 +112,13 @@ void TestAccountBasics::testBasics()
Telepathy::Avatar avatar = { QByteArray("asdfg"), "image/jpeg" };
QVERIFY(connect(acc->setAvatar(avatar),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(connect(acc->becomeReady(Account::FeatureAvatar),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(acc->isReady(Account::FeatureAvatar), true);
@@ -128,22 +128,22 @@ void TestAccountBasics::testBasics()
pacc = mAM->createAccount("spurious",
"normal", "foobar", parameters);
QVERIFY(connect(pacc,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
acc = mAM->accountForPath(
"/org/freedesktop/Telepathy/Account/spurious/normal/Account0");
QVERIFY(connect(acc->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
acc = mAM->accountForPath(
"/org/freedesktop/Telepathy/Account/spurious/normal/Account0");
QVERIFY(connect(acc->becomeReady(Account::FeatureProtocolInfo),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(acc->isReady(Account::FeatureProtocolInfo), true);
@@ -154,16 +154,16 @@ void TestAccountBasics::testBasics()
QCOMPARE(protocolInfo->hasParameter("register"), true);
QVERIFY(connect(acc->becomeReady(Account::FeatureAvatar),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(acc->isReady(Account::FeatureAvatar), true);
QCOMPARE(acc->avatar().MIMEType, QString("image/png"));
QVERIFY(connect(acc->becomeReady(Account::FeatureAvatar | Account::FeatureProtocolInfo),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(acc->isReady(Account::FeatureAvatar | Account::FeatureProtocolInfo), true);
diff --git a/tests/dbus/chan-basics.cpp b/tests/dbus/chan-basics.cpp
index 2787120..2f51b47 100644
--- a/tests/dbus/chan-basics.cpp
+++ b/tests/dbus/chan-basics.cpp
@@ -18,7 +18,7 @@
#include <tests/lib/echo2/conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestChanBasics : public Test
{
@@ -32,9 +32,9 @@ public:
protected Q_SLOTS:
void expectConnReady(uint, uint);
void expectConnInvalidated();
- void expectPendingHandleFinished(Telepathy::Client::PendingOperation*);
- void expectCreateChannelFinished(Telepathy::Client::PendingOperation *);
- void expectEnsureChannelFinished(Telepathy::Client::PendingOperation *);
+ void expectPendingHandleFinished(Telepathy::PendingOperation*);
+ void expectCreateChannelFinished(Telepathy::PendingOperation *);
+ void expectEnsureChannelFinished(Telepathy::PendingOperation *);
private Q_SLOTS:
void initTestCase();
@@ -205,8 +205,8 @@ void TestChanBasics::initTestCase()
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(mConn->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
@@ -238,13 +238,13 @@ void TestChanBasics::testRequestHandle()
// Request handles for the identifiers and wait for the request to process
PendingHandles *pending = mConn->requestHandles(Telepathy::HandleTypeContact, ids);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingHandleFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingHandleFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(disconnect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectPendingHandleFinished(Telepathy::Client::PendingOperation*))));
+ SLOT(expectPendingHandleFinished(Telepathy::PendingOperation*))));
QVERIFY(mHandle != 0);
}
@@ -258,14 +258,14 @@ void TestChanBasics::testCreateChannel()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
mHandle);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mChan) {
QVERIFY(connect(mChan->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->isReady(), true);
QCOMPARE(mChan->isRequested(), true);
@@ -298,14 +298,14 @@ void TestChanBasics::testEnsureChannel()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
mHandle);
QVERIFY(connect(mConn->ensureChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectEnsureChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectEnsureChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mChan) {
QVERIFY(connect(mChan->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->isReady(), true);
QCOMPARE(mChan->isRequested(), true);
@@ -325,8 +325,8 @@ void TestChanBasics::testEnsureChannel()
QCOMPARE(ids, toCheck);
QVERIFY(connect(mChan->requestClose(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->isValid(), false);
@@ -344,13 +344,13 @@ void TestChanBasics::cleanupTestCase()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
diff --git a/tests/dbus/chan-group.cpp b/tests/dbus/chan-group.cpp
index 80a6ff9..9ff942c 100644
--- a/tests/dbus/chan-group.cpp
+++ b/tests/dbus/chan-group.cpp
@@ -20,7 +20,7 @@
#include <tests/lib/csh/conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestChanGroup : public Test
{
@@ -35,17 +35,17 @@ public:
protected Q_SLOTS:
void expectConnReady(uint, uint);
void expectConnInvalidated();
- void expectPendingRoomHandlesFinished(Telepathy::Client::PendingOperation*);
- void expectPendingContactHandlesFinished(Telepathy::Client::PendingOperation*);
- void expectCreateChannelFinished(Telepathy::Client::PendingOperation *);
- void expectPendingContactsFinished(Telepathy::Client::PendingOperation *);
+ void expectPendingRoomHandlesFinished(Telepathy::PendingOperation*);
+ void expectPendingContactHandlesFinished(Telepathy::PendingOperation*);
+ void expectCreateChannelFinished(Telepathy::PendingOperation *);
+ void expectPendingContactsFinished(Telepathy::PendingOperation *);
void onChannelGroupFlagsChanged(uint, uint, uint);
void onGroupMembersChanged(
- const Telepathy::Client::Contacts &groupMembersAdded,
- const Telepathy::Client::Contacts &groupLocalPendingMembersAdded,
- const Telepathy::Client::Contacts &groupRemotePendingMembersAdded,
- const Telepathy::Client::Contacts &groupMembersRemoved,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &details);
+ const Telepathy::Contacts &groupMembersAdded,
+ const Telepathy::Contacts &groupLocalPendingMembersAdded,
+ const Telepathy::Contacts &groupRemotePendingMembersAdded,
+ const Telepathy::Contacts &groupMembersRemoved,
+ const Telepathy::Channel::GroupMemberChangeDetails &details);
private Q_SLOTS:
void initTestCase();
@@ -312,8 +312,8 @@ void TestChanGroup::initTestCase()
mConn->requestConnect();
QVERIFY(connect(mConn->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
@@ -348,13 +348,13 @@ void TestChanGroup::testRequestHandle()
// Request handles for the identifiers and wait for the request to process
PendingHandles *pending = mConn->requestHandles(Telepathy::HandleTypeRoom, ids);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingRoomHandlesFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingRoomHandlesFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(disconnect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectPendingRoomHandlesFinished(Telepathy::Client::PendingOperation*))));
+ SLOT(expectPendingRoomHandlesFinished(Telepathy::PendingOperation*))));
}
void TestChanGroup::testCreateChannel()
@@ -405,14 +405,14 @@ void TestChanGroup::doTestCreateChannel()
mRoomHandles[mRoomNumber]);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan);
QVERIFY(connect(mChan->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->isReady(), true);
@@ -436,17 +436,17 @@ void TestChanGroup::doTestCreateChannel()
QVERIFY(connect(mChan.data(),
SIGNAL(groupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &)),
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &)),
SLOT(onGroupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &))));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &))));
if (mChan->groupContacts().count() != 5) {
// wait the initial contacts to be added to the group
@@ -471,14 +471,14 @@ void TestChanGroup::doTestCreateChannel()
QString("mary@#room%1").arg(mRoomNumber) <<
QString("another anonymous coward@#room%1").arg(mRoomNumber);
QVERIFY(connect(mConn->requestHandles(Telepathy::HandleTypeContact, ids),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactHandlesFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactHandlesFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Wait for the contacts to be built
QVERIFY(connect(mConn->contactManager()->contactsForHandles(mContactHandles),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mContacts.size(), 3);
@@ -573,13 +573,13 @@ void TestChanGroup::cleanupTestCase()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
diff --git a/tests/dbus/cm-basics.cpp b/tests/dbus/cm-basics.cpp
index 072fff7..37fcefe 100644
--- a/tests/dbus/cm-basics.cpp
+++ b/tests/dbus/cm-basics.cpp
@@ -16,7 +16,7 @@
#include <tests/lib/simple-manager.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestCmBasics : public Test
{
@@ -38,7 +38,7 @@ private Q_SLOTS:
private:
TpBaseConnectionManager *mCMService;
- Telepathy::Client::ConnectionManagerPtr mCM;
+ Telepathy::ConnectionManagerPtr mCM;
};
void TestCmBasics::initTestCase()
@@ -73,15 +73,15 @@ void TestCmBasics::init()
void TestCmBasics::testBasics()
{
QVERIFY(connect(mCM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mCM->isReady(), true);
// calling becomeReady() twice is a no-op
QVERIFY(connect(mCM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mCM->isReady(), true);
diff --git a/tests/dbus/conn-basics.cpp b/tests/dbus/conn-basics.cpp
index d94df33..3cf332b 100644
--- a/tests/dbus/conn-basics.cpp
+++ b/tests/dbus/conn-basics.cpp
@@ -15,7 +15,7 @@
#include <tests/lib/contacts-conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestConnBasics : public Test
{
@@ -127,8 +127,8 @@ void TestConnBasics::init()
qDebug() << "waiting connection to become ready";
QVERIFY(connect(mConn->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
qDebug() << "connection is now ready";
@@ -151,8 +151,8 @@ void TestConnBasics::testSimplePresence()
Features features = Features() << Connection::FeatureSimplePresence;
QCOMPARE(mConn->isReady(features), false);
QVERIFY(connect(mConn->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
@@ -164,13 +164,13 @@ void TestConnBasics::cleanup()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
diff --git a/tests/dbus/conn-requests.cpp b/tests/dbus/conn-requests.cpp
index 79d95b7..f307d09 100644
--- a/tests/dbus/conn-requests.cpp
+++ b/tests/dbus/conn-requests.cpp
@@ -18,7 +18,7 @@
#include <tests/lib/echo2/conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestConnRequests : public Test
{
@@ -31,9 +31,9 @@ public:
protected Q_SLOTS:
void expectConnInvalidated();
- void expectPendingHandleFinished(Telepathy::Client::PendingOperation*);
- void expectCreateChannelFinished(Telepathy::Client::PendingOperation *);
- void expectEnsureChannelFinished(Telepathy::Client::PendingOperation *);
+ void expectPendingHandleFinished(Telepathy::PendingOperation*);
+ void expectCreateChannelFinished(Telepathy::PendingOperation *);
+ void expectEnsureChannelFinished(Telepathy::PendingOperation *);
private Q_SLOTS:
void initTestCase();
@@ -177,8 +177,8 @@ void TestConnRequests::initTestCase()
QCOMPARE(mConn->isReady(), false);
QVERIFY(connect(mConn->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
@@ -200,13 +200,13 @@ void TestConnRequests::testRequestHandle()
// Request handles for the identifiers and wait for the request to process
PendingHandles *pending = mConn->requestHandles(Telepathy::HandleTypeContact, ids);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingHandleFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingHandleFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(disconnect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectPendingHandleFinished(Telepathy::Client::PendingOperation*))));
+ SLOT(expectPendingHandleFinished(Telepathy::PendingOperation*))));
QVERIFY(mHandle != 0);
}
@@ -220,8 +220,8 @@ void TestConnRequests::testCreateChannel()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
mHandle);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
}
@@ -235,8 +235,8 @@ void TestConnRequests::testEnsureChannel()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
mHandle);
QVERIFY(connect(mConn->ensureChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectEnsureChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectEnsureChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
}
@@ -250,13 +250,13 @@ void TestConnRequests::cleanupTestCase()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
diff --git a/tests/dbus/conn-roster.cpp b/tests/dbus/conn-roster.cpp
index 979890b..f2a37bd 100644
--- a/tests/dbus/conn-roster.cpp
+++ b/tests/dbus/conn-roster.cpp
@@ -18,7 +18,7 @@
#include <tests/lib/contactlist/conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestConnRoster : public Test
{
@@ -31,8 +31,8 @@ public:
protected Q_SLOTS:
void expectConnInvalidated();
- void expectPendingContactsFinished(Telepathy::Client::PendingOperation *);
- void expectPresenceStateChanged(Telepathy::Client::Contact::PresenceState);
+ void expectPendingContactsFinished(Telepathy::PendingOperation *);
+ void expectPresenceStateChanged(Telepathy::Contact::PresenceState);
private Q_SLOTS:
void initTestCase();
@@ -128,8 +128,8 @@ void TestConnRoster::init()
mConn = Connection::create(mConnName, mConnPath);
QVERIFY(connect(mConn->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
QCOMPARE(mConn->status(), static_cast<uint>(Connection::StatusConnected));
@@ -139,9 +139,9 @@ void TestConnRoster::testRoster()
{
Features features = Features() << Connection::FeatureRoster;
QVERIFY(connect(mConn->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
@@ -178,18 +178,18 @@ void TestConnRoster::testRoster()
// Wait for the contacts to be built
ids = QStringList() << QString("john at example.com") << QString("mary at example.com");
QVERIFY(connect(mConn->contactManager()->contactsForIdentifiers(ids),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
int i = 0;
foreach (const ContactPtr &contact, mContacts) {
QVERIFY(connect(contact.data(),
- SIGNAL(subscriptionStateChanged(Telepathy::Client::Contact::PresenceState)),
- SLOT(expectPresenceStateChanged(Telepathy::Client::Contact::PresenceState))));
+ SIGNAL(subscriptionStateChanged(Telepathy::Contact::PresenceState)),
+ SLOT(expectPresenceStateChanged(Telepathy::Contact::PresenceState))));
QVERIFY(connect(contact.data(),
- SIGNAL(publishStateChanged(Telepathy::Client::Contact::PresenceState)),
- SLOT(expectPresenceStateChanged(Telepathy::Client::Contact::PresenceState))));
+ SIGNAL(publishStateChanged(Telepathy::Contact::PresenceState)),
+ SLOT(expectPresenceStateChanged(Telepathy::Contact::PresenceState))));
if ((i % 2) == 0) {
contact->requestPresenceSubscription("please add me");
} else {
@@ -234,8 +234,8 @@ void TestConnRoster::testRoster()
Contact::PresenceState expectedPresenceState;
foreach (const ContactPtr &contact, pendingPublish) {
QVERIFY(connect(contact.data(),
- SIGNAL(publishStateChanged(Telepathy::Client::Contact::PresenceState)),
- SLOT(expectPresenceStateChanged(Telepathy::Client::Contact::PresenceState))));
+ SIGNAL(publishStateChanged(Telepathy::Contact::PresenceState)),
+ SLOT(expectPresenceStateChanged(Telepathy::Contact::PresenceState))));
if ((i % 2) == 0) {
expectedPresenceState = Contact::PresenceStateYes;
@@ -258,13 +258,13 @@ void TestConnRoster::cleanup()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
diff --git a/tests/dbus/contacts.cpp b/tests/dbus/contacts.cpp
index 5044078..8651f3c 100644
--- a/tests/dbus/contacts.cpp
+++ b/tests/dbus/contacts.cpp
@@ -21,7 +21,7 @@
#include <tests/lib/simple-conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestContacts : public Test
{
@@ -36,7 +36,7 @@ public:
protected Q_SLOTS:
void expectConnReady(uint newStatus, uint newStatusReason);
void expectConnInvalidated();
- void expectPendingContactsFinished(Telepathy::Client::PendingOperation *);
+ void expectPendingContactsFinished(Telepathy::PendingOperation *);
private Q_SLOTS:
void initTestCase();
@@ -160,8 +160,8 @@ void TestContacts::initTestCase()
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(mConn->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
@@ -258,8 +258,8 @@ void TestContacts::testForHandles()
// Wait for the contacts to be built
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// There should be 3 resulting contacts and 2 handles found to be invalid
@@ -293,8 +293,8 @@ void TestContacts::testForHandles()
pending = mConn->contactManager()->contactsForHandles(handles);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that we got the correct number of contacts back
@@ -339,8 +339,8 @@ void TestContacts::testForIdentifiers()
// Check that a request with just the invalid IDs fails
PendingContacts *fails = mConn->contactManager()->contactsForIdentifiers(invalidIDs);
QVERIFY(connect(fails,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
toCheck = fails->invalidIdentifiers().keys();
toCheck.sort();
@@ -350,8 +350,8 @@ void TestContacts::testForIdentifiers()
// A request with both valid and invalid IDs should succeed
fails = mConn->contactManager()->contactsForIdentifiers(invalidIDs + validIDs + invalidIDs);
QVERIFY(connect(fails,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(fails->validIdentifiers(), validIDs);
toCheck = fails->invalidIdentifiers().keys();
@@ -374,8 +374,8 @@ void TestContacts::testForIdentifiers()
// Finish it
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that there are 3 contacts consistent with the request
@@ -471,8 +471,8 @@ void TestContacts::testFeatures()
// Build contacts
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles, features);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check the contact contents
@@ -582,8 +582,8 @@ void TestContacts::testFeaturesNotRequested()
// Build contacts (note: no features)
PendingContacts *pending = mConn->contactManager()->contactsForHandles(handles);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that the feature accessors return sensible fallback values (note: the warnings are
@@ -659,8 +659,8 @@ void TestContacts::testUpgrade()
// Wait for the contacts to be built
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// There should be 3 resulting contacts - save them for future reference
@@ -686,8 +686,8 @@ void TestContacts::testUpgrade()
// Wait for the contacts to be built
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// Check that we got the correct contacts back
@@ -764,8 +764,8 @@ void TestContacts::testSelfContactFallback()
Features features = Features() << Connection::FeatureSelfContact;
QVERIFY(connect(conn->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(conn->isReady(features), true);
@@ -797,13 +797,13 @@ void TestContacts::cleanupTestCase()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, QString, QString)),
+ SIGNAL(invalidated(Telepathy::DBusProxy *, QString, QString)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
}
diff --git a/tests/dbus/handles.cpp b/tests/dbus/handles.cpp
index 7e67fb3..54f1530 100644
--- a/tests/dbus/handles.cpp
+++ b/tests/dbus/handles.cpp
@@ -17,7 +17,7 @@
#include <tests/lib/simple-conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestHandles : public Test
{
@@ -31,7 +31,7 @@ public:
protected Q_SLOTS:
void expectConnReady(uint newStatus, uint newStatusReason);
void expectConnInvalidated();
- void expectPendingHandlesFinished(Telepathy::Client::PendingOperation*);
+ void expectPendingHandlesFinished(Telepathy::PendingOperation*);
private Q_SLOTS:
void initTestCase();
@@ -141,8 +141,8 @@ void TestHandles::initTestCase()
mConn->requestConnect();
QVERIFY(connect(mConn->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
@@ -172,13 +172,13 @@ void TestHandles::testRequestAndRelease()
// Request handles for the identifiers and wait for the request to process
PendingHandles *pending = mConn->requestHandles(Telepathy::HandleTypeContact, ids);
QVERIFY(connect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(disconnect(pending,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
ReferencedHandles handles = mHandles;
mHandles = ReferencedHandles();
@@ -218,13 +218,13 @@ void TestHandles::cleanupTestCase()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *, const QString &, const QString &)),
+ SIGNAL(invalidated(Telepathy::DBusProxy *, const QString &, const QString &)),
SLOT(expectConnInvalidated())));
QCOMPARE(mLoop->exec(), 0);
}
diff --git a/tests/dbus/stateful-proxy.cpp b/tests/dbus/stateful-proxy.cpp
index f099406..820f0f3 100644
--- a/tests/dbus/stateful-proxy.cpp
+++ b/tests/dbus/stateful-proxy.cpp
@@ -31,7 +31,7 @@
#include "tests/lib/test.h"
using namespace Telepathy;
-using namespace Telepathy::Client;
+using namespace Telepathy;
using Telepathy::Client::DBus::IntrospectableInterface;
// expose protected functions for testing
@@ -79,7 +79,7 @@ private Q_SLOTS:
protected Q_SLOTS:
// these would be public, but then QtTest would think they were tests
- void expectInvalidated(Telepathy::Client::DBusProxy *,
+ void expectInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &);
// anything other than 0 or 1 is OK
@@ -183,10 +183,10 @@ void TestStatefulProxy::testBasics()
}
QVERIFY(connect(mProxy, SIGNAL(invalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &)),
this, SLOT(expectInvalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &))));
mProxy->invalidate("com.example.DomainSpecificError",
"Because I said so");
@@ -212,10 +212,10 @@ void TestStatefulProxy::testBasics()
// the signal doesn't arrive instantly
QCOMPARE(mLoop->exec(), EXPECT_INVALIDATED_SUCCESS);
QVERIFY(disconnect(mProxy, SIGNAL(invalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &)),
this, SLOT(expectInvalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &))));
QCOMPARE(mInvalidated, 1);
@@ -274,18 +274,18 @@ void TestStatefulProxy::testNameOwnerChanged()
QCOMPARE(mProxy->invalidationMessage(), QString());
QVERIFY(connect(mProxy, SIGNAL(invalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &)),
this, SLOT(expectInvalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &))));
QDBusConnection::disconnectFromBus("another unique name");
QCOMPARE(mLoop->exec(), EXPECT_INVALIDATED_SUCCESS);
QVERIFY(disconnect(mProxy, SIGNAL(invalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &)),
this, SLOT(expectInvalidated(
- Telepathy::Client::DBusProxy *,
+ Telepathy::DBusProxy *,
const QString &, const QString &))));
QCOMPARE(mInvalidated, 1);
diff --git a/tests/dbus/streamed-media-chan.cpp b/tests/dbus/streamed-media-chan.cpp
index a350b82..f38d22e 100644
--- a/tests/dbus/streamed-media-chan.cpp
+++ b/tests/dbus/streamed-media-chan.cpp
@@ -14,7 +14,7 @@
#include <tests/lib/callable/conn.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestStreamedMediaChan : public Test
{
@@ -26,22 +26,22 @@ public:
{ }
protected Q_SLOTS:
- void expectRequestContactsFinished(Telepathy::Client::PendingOperation *);
- void expectCreateChannelFinished(Telepathy::Client::PendingOperation *);
- void expectRequestStreamsFinished(Telepathy::Client::PendingOperation *);
+ void expectRequestContactsFinished(Telepathy::PendingOperation *);
+ void expectCreateChannelFinished(Telepathy::PendingOperation *);
+ void expectRequestStreamsFinished(Telepathy::PendingOperation *);
void onGroupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &);
- void onStreamRemoved(const Telepathy::Client::MediaStreamPtr &);
- void onStreamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &);
+ void onStreamRemoved(const Telepathy::MediaStreamPtr &);
+ void onStreamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend);
- void onStreamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ void onStreamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState);
- void onChanInvalidated(Telepathy::Client::DBusProxy *,
+ void onChanInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &);
void onNewChannels(const Telepathy::ChannelDetailsList &);
@@ -200,7 +200,7 @@ void TestStreamedMediaChan::onStreamStateChanged(const MediaStreamPtr &stream,
mLoop->exit(0);
}
-void TestStreamedMediaChan::onChanInvalidated(Telepathy::Client::DBusProxy *proxy,
+void TestStreamedMediaChan::onChanInvalidated(Telepathy::DBusProxy *proxy,
const QString &errorName, const QString &errorMessage)
{
qDebug() << "chan invalidated:" << errorName << "-" << errorMessage;
@@ -262,8 +262,8 @@ void TestStreamedMediaChan::initTestCase()
QCOMPARE(mConn->isReady(), false);
QVERIFY(connect(mConn->requestConnect(Connection::FeatureSelfContact),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
QCOMPARE(static_cast<uint>(mConn->status()),
@@ -291,8 +291,8 @@ void TestStreamedMediaChan::init()
void TestStreamedMediaChan::testOutgoingCall()
{
QVERIFY(connect(mConn->contactManager()->contactsForIdentifiers(QStringList() << "alice"),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mRequestContactsReturn.size() == 1);
ContactPtr otherContact = mRequestContactsReturn.first();
@@ -306,14 +306,14 @@ void TestStreamedMediaChan::testOutgoingCall()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
otherContact->handle()[0]);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan);
QVERIFY(connect(mChan->becomeReady(StreamedMediaChannel::FeatureStreams),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan->isReady(StreamedMediaChannel::FeatureStreams));
@@ -326,30 +326,30 @@ void TestStreamedMediaChan::testOutgoingCall()
QVERIFY(connect(mChan.data(),
SIGNAL(groupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &)),
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &)),
SLOT(onGroupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &))));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &))));
// RequestStreams with bad type must fail
QVERIFY(connect(mChan->requestStream(otherContact, (Telepathy::MediaStreamType) -1),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 2);
QCOMPARE(mRequestStreamsReturn.size(), 0);
// Request audio stream
QVERIFY(connect(mChan->requestStreams(otherContact,
QList<Telepathy::MediaStreamType>() << Telepathy::MediaStreamTypeAudio),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mRequestStreamsReturn.size(), 1);
MediaStreamPtr stream = mRequestStreamsReturn.first();
@@ -379,8 +379,8 @@ void TestStreamedMediaChan::testOutgoingCall()
// Request video stream
QVERIFY(connect(mChan->requestStream(otherContact, Telepathy::MediaStreamTypeVideo),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mRequestStreamsReturn.size(), 1);
stream = mRequestStreamsReturn.first();
@@ -401,11 +401,11 @@ void TestStreamedMediaChan::testOutgoingCall()
QVERIFY(stream);
QVERIFY(connect(mChan.data(),
- SIGNAL(streamRemoved(const Telepathy::Client::MediaStreamPtr &)),
- SLOT(onStreamRemoved(const Telepathy::Client::MediaStreamPtr &))));
+ SIGNAL(streamRemoved(const Telepathy::MediaStreamPtr &)),
+ SLOT(onStreamRemoved(const Telepathy::MediaStreamPtr &))));
QVERIFY(connect(mChan->removeStream(stream),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mChan->streams().size() == 2) {
// wait stream removed signal
@@ -421,20 +421,20 @@ void TestStreamedMediaChan::testOutgoingCall()
QVERIFY(stream);
QVERIFY(connect(mChan.data(),
- SIGNAL(streamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ SIGNAL(streamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend)),
- SLOT(onStreamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ SLOT(onStreamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend))));
QVERIFY(connect(mChan.data(),
- SIGNAL(streamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ SIGNAL(streamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState)),
- SLOT(onStreamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ SLOT(onStreamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState))));
QVERIFY(connect(stream->requestDirection(Telepathy::MediaStreamDirectionReceive),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (!mSDCStreamReturn) {
// wait direction and state changed signal
@@ -454,8 +454,8 @@ void TestStreamedMediaChan::testOutgoingCallBusy()
// This identifier contains the magic string (busy), which means the example
// will simulate rejection of the call as busy rather than accepting it.
QVERIFY(connect(mConn->contactManager()->contactsForIdentifiers(QStringList() << "alice (busy)"),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mRequestContactsReturn.size() == 1);
ContactPtr otherContact = mRequestContactsReturn.first();
@@ -469,14 +469,14 @@ void TestStreamedMediaChan::testOutgoingCallBusy()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
otherContact->handle()[0]);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan);
QVERIFY(connect(mChan->becomeReady(StreamedMediaChannel::FeatureStreams),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan->isReady(StreamedMediaChannel::FeatureStreams));
@@ -490,14 +490,14 @@ void TestStreamedMediaChan::testOutgoingCallBusy()
// Request audio stream
QVERIFY(connect(mChan->requestStreams(otherContact,
QList<Telepathy::MediaStreamType>() << Telepathy::MediaStreamTypeAudio),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(connect(mChan.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
- SLOT(onChanInvalidated(Telepathy::Client::DBusProxy *,
+ SLOT(onChanInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->groupContacts().size(), 0);
@@ -511,8 +511,8 @@ void TestStreamedMediaChan::testOutgoingCallNoAnswer()
// This identifier contains the magic string (no answer), which means the example
// will never answer.
QVERIFY(connect(mConn->contactManager()->contactsForIdentifiers(QStringList() << "alice (no answer)"),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mRequestContactsReturn.size() == 1);
ContactPtr otherContact = mRequestContactsReturn.first();
@@ -526,14 +526,14 @@ void TestStreamedMediaChan::testOutgoingCallNoAnswer()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
otherContact->handle()[0]);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan);
QVERIFY(connect(mChan->becomeReady(StreamedMediaChannel::FeatureStreams),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan->isReady(StreamedMediaChannel::FeatureStreams));
@@ -547,8 +547,8 @@ void TestStreamedMediaChan::testOutgoingCallNoAnswer()
// Request audio stream
QVERIFY(connect(mChan->requestStreams(otherContact,
QList<Telepathy::MediaStreamType>() << Telepathy::MediaStreamTypeAudio),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
/* After the initial flurry of D-Bus messages, alice still hasn't answered */
@@ -556,17 +556,17 @@ void TestStreamedMediaChan::testOutgoingCallNoAnswer()
QVERIFY(connect(mChan.data(),
SIGNAL(groupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &)),
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &)),
SLOT(onGroupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &))));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &))));
// wait the contact to appear on RP
while (mChan->groupRemotePendingContacts().size() == 0) {
mLoop->processEvents();
@@ -579,9 +579,9 @@ void TestStreamedMediaChan::testOutgoingCallNoAnswer()
mChan->requestClose();
QVERIFY(connect(mChan.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
- SLOT(onChanInvalidated(Telepathy::Client::DBusProxy *,
+ SLOT(onChanInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->groupContacts().size(), 0);
@@ -595,8 +595,8 @@ void TestStreamedMediaChan::testOutgoingCallTerminate()
// This identifier contains the magic string (terminate), which means the example
// will simulate answering the call but then terminating it.
QVERIFY(connect(mConn->contactManager()->contactsForIdentifiers(QStringList() << "alice (terminate)"),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestContactsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestContactsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mRequestContactsReturn.size() == 1);
ContactPtr otherContact = mRequestContactsReturn.first();
@@ -610,14 +610,14 @@ void TestStreamedMediaChan::testOutgoingCallTerminate()
request.insert(QLatin1String(TELEPATHY_INTERFACE_CHANNEL ".TargetHandle"),
otherContact->handle()[0]);
QVERIFY(connect(mConn->createChannel(request),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectCreateChannelFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectCreateChannelFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan);
QVERIFY(connect(mChan->becomeReady(StreamedMediaChannel::FeatureStreams),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan->isReady(StreamedMediaChannel::FeatureStreams));
@@ -630,23 +630,23 @@ void TestStreamedMediaChan::testOutgoingCallTerminate()
QVERIFY(connect(mChan.data(),
SIGNAL(groupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &)),
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &)),
SLOT(onGroupMembersChanged(
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Contacts &,
- const Telepathy::Client::Channel::GroupMemberChangeDetails &))));
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Contacts &,
+ const Telepathy::Channel::GroupMemberChangeDetails &))));
// Request audio stream
QVERIFY(connect(mChan->requestStreams(otherContact,
QList<Telepathy::MediaStreamType>() << Telepathy::MediaStreamTypeAudio),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
// wait the contact to appear on RP
@@ -666,9 +666,9 @@ void TestStreamedMediaChan::testOutgoingCallTerminate()
// wait the contact to terminate the call
QVERIFY(connect(mChan.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
- SLOT(onChanInvalidated(Telepathy::Client::DBusProxy *,
+ SLOT(onChanInvalidated(Telepathy::DBusProxy *,
const QString &, const QString &))));
QCOMPARE(mLoop->exec(), 0);
}
@@ -687,8 +687,8 @@ void TestStreamedMediaChan::testIncomingCall()
QCOMPARE(mChan->streams().size(), 0);
QVERIFY(connect(mChan->becomeReady(StreamedMediaChannel::FeatureStreams),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(mChan->isReady(StreamedMediaChannel::FeatureStreams));
@@ -704,8 +704,8 @@ void TestStreamedMediaChan::testIncomingCall()
QCOMPARE(otherContact, mChan->initiatorContact());
QVERIFY(connect(mChan->acceptCall(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mChan->groupContacts().size(), 2);
QCOMPARE(mChan->groupLocalPendingContacts().size(), 0);
@@ -720,15 +720,15 @@ void TestStreamedMediaChan::testIncomingCall()
// RequestStreams with bad type must fail
QVERIFY(connect(mChan->requestStream(otherContact, (Telepathy::MediaStreamType) -1),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 2);
QCOMPARE(mRequestStreamsReturn.size(), 0);
// Request video stream
QVERIFY(connect(mChan->requestStream(otherContact, Telepathy::MediaStreamTypeVideo),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectRequestStreamsFinished(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectRequestStreamsFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mRequestStreamsReturn.size(), 1);
stream = mRequestStreamsReturn.first();
@@ -749,11 +749,11 @@ void TestStreamedMediaChan::testIncomingCall()
QVERIFY(stream);
QVERIFY(connect(mChan.data(),
- SIGNAL(streamRemoved(const Telepathy::Client::MediaStreamPtr &)),
- SLOT(onStreamRemoved(const Telepathy::Client::MediaStreamPtr &))));
+ SIGNAL(streamRemoved(const Telepathy::MediaStreamPtr &)),
+ SLOT(onStreamRemoved(const Telepathy::MediaStreamPtr &))));
QVERIFY(connect(mChan->removeStreams(MediaStreams() << stream),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mChan->streams().size() == 2) {
// wait stream removed signal
@@ -769,20 +769,20 @@ void TestStreamedMediaChan::testIncomingCall()
QVERIFY(stream);
QVERIFY(connect(mChan.data(),
- SIGNAL(streamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ SIGNAL(streamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend)),
- SLOT(onStreamDirectionChanged(const Telepathy::Client::MediaStreamPtr &,
+ SLOT(onStreamDirectionChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamDirection,
Telepathy::MediaStreamPendingSend))));
QVERIFY(connect(mChan.data(),
- SIGNAL(streamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ SIGNAL(streamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState)),
- SLOT(onStreamStateChanged(const Telepathy::Client::MediaStreamPtr &,
+ SLOT(onStreamStateChanged(const Telepathy::MediaStreamPtr &,
Telepathy::MediaStreamState))));
QVERIFY(connect(stream->requestDirection(false, true),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (!mSDCStreamReturn) {
// wait direction and state changed signal
@@ -807,13 +807,13 @@ void TestStreamedMediaChan::cleanupTestCase()
{
if (mConn) {
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
mLoop,
SLOT(quit())));
diff --git a/tests/dbus/text-chan.cpp b/tests/dbus/text-chan.cpp
index d1ae88b..286cb2a 100644
--- a/tests/dbus/text-chan.cpp
+++ b/tests/dbus/text-chan.cpp
@@ -19,7 +19,7 @@
#include <tests/lib/echo2/chan.h>
#include <tests/lib/test.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
using Telepathy::UIntList;
struct SentMessageDetails
@@ -46,9 +46,9 @@ public:
{ }
protected Q_SLOTS:
- void onMessageReceived(const Telepathy::Client::ReceivedMessage &);
- void onMessageRemoved(const Telepathy::Client::ReceivedMessage &);
- void onMessageSent(const Telepathy::Client::Message &,
+ void onMessageReceived(const Telepathy::ReceivedMessage &);
+ void onMessageRemoved(const Telepathy::ReceivedMessage &);
+ void onMessageSent(const Telepathy::Message &,
Telepathy::MessageSendingFlags, const QString &);
private Q_SLOTS:
@@ -93,7 +93,7 @@ void TestTextChan::onMessageRemoved(const ReceivedMessage &message)
removed << message;
}
-void TestTextChan::onMessageSent(const Telepathy::Client::Message &message,
+void TestTextChan::onMessageSent(const Telepathy::Message &message,
Telepathy::MessageSendingFlags flags, const QString &token)
{
sent << SentMessageDetails(message, flags, token);
@@ -103,8 +103,8 @@ void TestTextChan::sendText(const char *text)
{
QVERIFY(connect(mChan->send(QLatin1String(text),
Telepathy::ChannelTextMessageTypeNormal),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
}
@@ -149,8 +149,8 @@ void TestTextChan::initTestCase()
mConn->requestConnect();
QVERIFY(connect(mConn->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
QCOMPARE(static_cast<uint>(mConn->status()),
@@ -196,8 +196,8 @@ void TestTextChan::commonTest(bool withMessages)
ChannelPtr asChannel = ChannelPtr(dynamic_cast<Channel*>(mChan.data()));
QVERIFY(connect(asChannel->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(asChannel->isReady());
@@ -210,19 +210,19 @@ void TestTextChan::commonTest(bool withMessages)
QVERIFY(!mChan->isReady(features));
QVERIFY(connect(mChan.data(),
- SIGNAL(messageReceived(const Telepathy::Client::ReceivedMessage &)),
- SLOT(onMessageReceived(const Telepathy::Client::ReceivedMessage &))));
+ SIGNAL(messageReceived(const Telepathy::ReceivedMessage &)),
+ SLOT(onMessageReceived(const Telepathy::ReceivedMessage &))));
QCOMPARE(received.size(), 0);
QVERIFY(connect(mChan.data(),
- SIGNAL(pendingMessageRemoved(const Telepathy::Client::ReceivedMessage &)),
- SLOT(onMessageRemoved(const Telepathy::Client::ReceivedMessage &))));
+ SIGNAL(pendingMessageRemoved(const Telepathy::ReceivedMessage &)),
+ SLOT(onMessageRemoved(const Telepathy::ReceivedMessage &))));
QCOMPARE(removed.size(), 0);
QVERIFY(connect(mChan.data(),
- SIGNAL(messageSent(const Telepathy::Client::Message &,
+ SIGNAL(messageSent(const Telepathy::Message &,
Telepathy::MessageSendingFlags,
const QString &)),
- SLOT(onMessageSent(const Telepathy::Client::Message &,
+ SLOT(onMessageSent(const Telepathy::Message &,
Telepathy::MessageSendingFlags,
const QString &))));
QCOMPARE(sent.size(), 0);
@@ -232,8 +232,8 @@ void TestTextChan::commonTest(bool withMessages)
// Make the Sent signal become ready
features = Features() << TextChannel::FeatureMessageSentSignal;
QVERIFY(connect(mChan->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(asChannel->isReady());
@@ -268,8 +268,8 @@ void TestTextChan::commonTest(bool withMessages)
// Make capabilities become ready
features = Features() << TextChannel::FeatureMessageCapabilities;
QVERIFY(connect(mChan->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(asChannel->isReady());
@@ -296,8 +296,8 @@ void TestTextChan::commonTest(bool withMessages)
QCOMPARE(mChan->messageQueue().size(), 0);
features = Features() << TextChannel::FeatureMessageQueue;
QVERIFY(connect(mChan->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *))));
+ SIGNAL(finished(Telepathy::PendingOperation *)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(asChannel->isReady());
@@ -436,13 +436,13 @@ void TestTextChan::cleanupTestCase()
if (mConn) {
// Disconnect and wait for the readiness change
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
if (mConn->isValid()) {
QVERIFY(connect(mConn.data(),
- SIGNAL(invalidated(Telepathy::Client::DBusProxy *,
+ SIGNAL(invalidated(Telepathy::DBusProxy *,
const QString &, const QString &)),
mLoop,
SLOT(quit())));
diff --git a/tests/lib/test.cpp b/tests/lib/test.cpp
index 25e858e..1dfb6bc 100644
--- a/tests/lib/test.cpp
+++ b/tests/lib/test.cpp
@@ -9,7 +9,9 @@
#include <TelepathyQt4/DBus>
#include <TelepathyQt4/PendingVoidMethodCall>
-using Telepathy::Client::PendingOperation;
+using Telepathy::PendingOperation;
+using Telepathy::PendingVoidMethodCall;
+using Telepathy::Client::DBus::PeerInterface;
Test::Test(QObject *parent)
: QObject(parent), mLoop(new QEventLoop(this))
@@ -66,19 +68,16 @@ void Test::expectSuccessfulCall(QDBusPendingCallWatcher *watcher)
mLoop->exit(0);
}
-void Test::processDBusQueue(Telepathy::Client::DBusProxy *proxy)
+void Test::processDBusQueue(Telepathy::DBusProxy *proxy)
{
- using Telepathy::Client::DBus::PeerInterface;
- using Telepathy::Client::PendingVoidMethodCall;
-
// Call method Ping on the D-Bus Peer interface
PeerInterface peer(proxy);
PendingVoidMethodCall *call = new PendingVoidMethodCall(this, peer.Ping());
// Wait for the reply to the Ping call
QVERIFY(connect(call,
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SIGNAL(finished(Telepathy::PendingOperation*)),
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
}
diff --git a/tests/lib/test.h b/tests/lib/test.h
index eeaed47..8c21864 100644
--- a/tests/lib/test.h
+++ b/tests/lib/test.h
@@ -7,11 +7,8 @@
namespace Telepathy
{
-namespace Client
-{
class DBusProxy;
}
-}
class Test : public QObject
{
@@ -24,11 +21,11 @@ public:
virtual ~Test();
QEventLoop *mLoop;
- void processDBusQueue(Telepathy::Client::DBusProxy *proxy);
+ void processDBusQueue(Telepathy::DBusProxy *proxy);
protected Q_SLOTS:
void expectSuccessfulCall(QDBusPendingCallWatcher*);
- void expectSuccessfulCall(Telepathy::Client::PendingOperation*);
+ void expectSuccessfulCall(Telepathy::PendingOperation*);
virtual void initTestCaseImpl();
virtual void initImpl();
diff --git a/tests/pinocchio/cm-basics.cpp b/tests/pinocchio/cm-basics.cpp
index 058f543..08ea129 100644
--- a/tests/pinocchio/cm-basics.cpp
+++ b/tests/pinocchio/cm-basics.cpp
@@ -10,17 +10,17 @@
#include <tests/pinocchio/lib.h>
-using namespace Telepathy::Client;
+using namespace Telepathy;
class TestCmBasics : public PinocchioTest
{
Q_OBJECT
private:
- Telepathy::Client::ConnectionManagerPtr mCM;
+ Telepathy::ConnectionManagerPtr mCM;
protected Q_SLOTS:
- void onListNames(Telepathy::Client::PendingOperation*);
+ void onListNames(Telepathy::PendingOperation*);
private Q_SLOTS:
void initTestCase();
@@ -47,9 +47,9 @@ void TestCmBasics::init()
initImpl();
}
-void TestCmBasics::onListNames(Telepathy::Client::PendingOperation *operation)
+void TestCmBasics::onListNames(Telepathy::PendingOperation *operation)
{
- Telepathy::Client::PendingStringList *p = static_cast<Telepathy::Client::PendingStringList*>(operation);
+ Telepathy::PendingStringList *p = static_cast<Telepathy::PendingStringList*>(operation);
QCOMPARE(p->result().contains("pinocchio"), QBool(true));
mLoop->exit(0);
}
@@ -58,27 +58,27 @@ void TestCmBasics::onListNames(Telepathy::Client::PendingOperation *operation)
void TestCmBasics::testBasics()
{
connect(ConnectionManager::listNames(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
+ SIGNAL(finished(Telepathy::PendingOperation *)),
this,
- SLOT(onListNames(Telepathy::Client::PendingOperation *)));
+ SLOT(onListNames(Telepathy::PendingOperation *)));
QCOMPARE(mLoop->exec(), 0);
mCM = ConnectionManager::create("pinocchio");
QCOMPARE(mCM->isReady(), false);
connect(mCM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
+ SIGNAL(finished(Telepathy::PendingOperation *)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *)));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *)));
qDebug() << "enter main loop";
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mCM->isReady(), true);
// calling becomeReady() twice is a no-op
connect(mCM->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
+ SIGNAL(finished(Telepathy::PendingOperation *)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *)));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *)));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mCM->isReady(), true);
@@ -118,9 +118,9 @@ void TestCmBasics::testBasics()
PendingConnection *pconn = mCM->requestConnection("dummy", parameters);
connect(pconn,
- SIGNAL(finished(Telepathy::Client::PendingOperation *)),
+ SIGNAL(finished(Telepathy::PendingOperation *)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation *)));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation *)));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(pconn->connection());
diff --git a/tests/pinocchio/conn-basics.cpp b/tests/pinocchio/conn-basics.cpp
index f5bcb5d..7ae5e9a 100644
--- a/tests/pinocchio/conn-basics.cpp
+++ b/tests/pinocchio/conn-basics.cpp
@@ -11,19 +11,19 @@
#include <tests/pinocchio/lib.h>
-using Telepathy::Client::Connection;
-using Telepathy::Client::ConnectionPtr;
+using Telepathy::Connection;
+using Telepathy::ConnectionPtr;
using Telepathy::Client::ConnectionManagerInterface;
using Telepathy::Client::DBus::PeerInterface;
using Telepathy::Client::DBus::PropertiesInterface;
-using Telepathy::Client::Features;
+using Telepathy::Features;
class TestConnBasics : public PinocchioTest
{
Q_OBJECT
private:
- Telepathy::Client::ConnectionManagerInterface* mCM;
+ ConnectionManagerInterface* mCM;
QString mConnBusName;
QString mConnObjectPath;
ConnectionPtr mConn;
@@ -143,15 +143,15 @@ void TestConnBasics::testConnect()
qDebug() << "calling Connect()";
QVERIFY(connect(mConn->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(connect(mConn->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
@@ -169,9 +169,9 @@ void TestConnBasics::testConnect()
Features features = Features() << Connection::FeatureSimplePresence;
QVERIFY(connect(mConn->becomeReady(features),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(features), true);
QVERIFY(mConn->missingFeatures() == features);
@@ -190,9 +190,9 @@ void TestConnBasics::testConnect()
TELEPATHY_INTERFACE_CONNECTION_INTERFACE_CAPABILITIES)));
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(static_cast<uint>(mConn->status()),
@@ -210,15 +210,15 @@ void TestConnBasics::testAlreadyConnected()
qDebug() << "calling Connect()";
QVERIFY(connect(mConn->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QVERIFY(connect(mConn->becomeReady(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
QCOMPARE(mConn->isReady(), true);
@@ -246,9 +246,9 @@ void TestConnBasics::testAlreadyConnected()
this, SLOT(expectReady(uint, uint))));
QVERIFY(connect(mConn->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
mConn.reset();
diff --git a/tests/pinocchio/handles.cpp b/tests/pinocchio/handles.cpp
index df43fe3..188f122 100644
--- a/tests/pinocchio/handles.cpp
+++ b/tests/pinocchio/handles.cpp
@@ -17,6 +17,7 @@
#include <tests/pinocchio/lib.h>
+using namespace Telepathy;
using namespace Telepathy::Client;
class TestHandles : public PinocchioTest
@@ -41,7 +42,7 @@ protected Q_SLOTS:
// these ought to be private, but if they were, QTest would think they
// were test cases. So, they're protected instead
void expectConnReady(uint, uint);
- void expectPendingHandlesFinished(Telepathy::Client::PendingOperation*);
+ void expectPendingHandlesFinished(Telepathy::PendingOperation*);
private Q_SLOTS:
void initTestCase();
@@ -86,7 +87,7 @@ void TestHandles::initTestCase()
// Escape to the low-level API to make a Connection; this uses
// pseudo-blocking calls for simplicity. Do not do this in production code
- mCM = new Telepathy::Client::ConnectionManagerInterface(
+ mCM = new ConnectionManagerInterface(
pinocchioBusName(), pinocchioObjectPath());
QDBusPendingReply<QString, QDBusObjectPath> reply;
@@ -116,9 +117,9 @@ void TestHandles::initTestCase()
// Connecting one connects them all
QVERIFY(connect(mConn1a->requestConnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
ConnectionPtr connections[3] = {mConn1a, mConn1b, mConn2};
@@ -187,11 +188,11 @@ void TestHandles::testBasics()
QCOMPARE(pending->handleType(), static_cast<uint>(Telepathy::HandleTypeContact));
// Finish the request and extract the resulting ReferencedHandles
- QVERIFY(connect(pending, SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- this, SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ QVERIFY(connect(pending, SIGNAL(finished(Telepathy::PendingOperation*)),
+ this, SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
- QVERIFY(disconnect(pending, SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- this, SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ QVERIFY(disconnect(pending, SIGNAL(finished(Telepathy::PendingOperation*)),
+ this, SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
ReferencedHandles handles = mHandles;
mHandles = ReferencedHandles();
@@ -221,11 +222,11 @@ void TestHandles::testReferences()
// Get referenced handles for all 5 of the IDs
PendingHandles *allPending = mConn1a->requestHandles(Telepathy::HandleTypeContact, ids);
- QVERIFY(connect(allPending, SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- this, SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ QVERIFY(connect(allPending, SIGNAL(finished(Telepathy::PendingOperation*)),
+ this, SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
- QVERIFY(disconnect(allPending, SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- this, SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ QVERIFY(disconnect(allPending, SIGNAL(finished(Telepathy::PendingOperation*)),
+ this, SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
ReferencedHandles allHandles = mHandles;
mHandles = ReferencedHandles();
@@ -242,11 +243,11 @@ void TestHandles::testReferences()
// Get another fresh reference to the middle three using the Connection
PendingHandles *middlePending = mConn1a->referenceHandles(Telepathy::HandleTypeContact,
Telepathy::UIntList() << allHandles[1] << allHandles[2] << allHandles[3]);
- QVERIFY(connect(middlePending, SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- this, SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ QVERIFY(connect(middlePending, SIGNAL(finished(Telepathy::PendingOperation*)),
+ this, SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
- QVERIFY(disconnect(middlePending, SIGNAL(finished(Telepathy::Client::PendingOperation*)),
- this, SLOT(expectPendingHandlesFinished(Telepathy::Client::PendingOperation*))));
+ QVERIFY(disconnect(middlePending, SIGNAL(finished(Telepathy::PendingOperation*)),
+ this, SLOT(expectPendingHandlesFinished(Telepathy::PendingOperation*))));
ReferencedHandles middleHandles = mHandles;
mHandles = ReferencedHandles();
@@ -309,9 +310,9 @@ void TestHandles::cleanupTestCase()
// Disconnecting one disconnects them all, because they all poke the same
// remote Connection
QVERIFY(connect(mConn1a->requestDisconnect(),
- SIGNAL(finished(Telepathy::Client::PendingOperation*)),
+ SIGNAL(finished(Telepathy::PendingOperation*)),
this,
- SLOT(expectSuccessfulCall(Telepathy::Client::PendingOperation*))));
+ SLOT(expectSuccessfulCall(Telepathy::PendingOperation*))));
QCOMPARE(mLoop->exec(), 0);
delete mCM;
diff --git a/tests/pinocchio/lib.cpp b/tests/pinocchio/lib.cpp
index 8b4f99f..789a756 100644
--- a/tests/pinocchio/lib.cpp
+++ b/tests/pinocchio/lib.cpp
@@ -9,7 +9,7 @@
#include <TelepathyQt4/DBus>
using Telepathy::Client::DBus::DBusDaemonInterface;
-using Telepathy::Client::PendingOperation;
+using Telepathy::PendingOperation;
PinocchioTest::PinocchioTest(QObject *parent)
: Test(parent)
diff --git a/tools/qt4-client-gen.py b/tools/qt4-client-gen.py
index 0af6e34..fea4aa5 100644
--- a/tools/qt4-client-gen.py
+++ b/tools/qt4-client-gen.py
@@ -39,7 +39,7 @@ class Generator(object):
self.mainiface = opts.get('--mainiface', None)
self.must_define = opts.get('--must-define', None)
self.dbus_proxy = opts.get('--dbus-proxy',
- 'Telepathy::Client::DBusProxy')
+ 'Telepathy::DBusProxy')
ifacedom = xml.dom.minidom.parse(opts['--ifacexml'])
specdom = xml.dom.minidom.parse(opts['--specxml'])
except KeyError, k:
@@ -148,7 +148,7 @@ namespace %s
*
* Proxy class providing a 1:1 mapping of the D-Bus interface "%(dbusname)s."
*/
-class %(name)s : public Telepathy::Client::AbstractInterface
+class %(name)s : public Telepathy::AbstractInterface
{
Q_OBJECT
@@ -198,12 +198,12 @@ public:
self.b("""
%(name)s::%(name)s(const QString& busName, const QString& objectPath, QObject *parent)
- : Telepathy::Client::AbstractInterface(busName, objectPath, staticInterfaceName(), QDBusConnection::sessionBus(), parent)
+ : Telepathy::AbstractInterface(busName, objectPath, staticInterfaceName(), QDBusConnection::sessionBus(), parent)
{
}
%(name)s::%(name)s(const QDBusConnection& connection, const QString& busName, const QString& objectPath, QObject *parent)
- : Telepathy::Client::AbstractInterface(busName, objectPath, staticInterfaceName(), connection, parent)
+ : Telepathy::AbstractInterface(busName, objectPath, staticInterfaceName(), connection, parent)
{
}
""" % {'name' : name})
@@ -222,14 +222,14 @@ public:
self.b("""
%(name)s::%(name)s(%(dbus_proxy)s *proxy)
- : Telepathy::Client::AbstractInterface(proxy, staticInterfaceName())
+ : Telepathy::AbstractInterface(proxy, staticInterfaceName())
{
}
""" % {'name' : name,
'dbus_proxy' : self.dbus_proxy})
# Main interface
- mainiface = self.mainiface or 'Telepathy::Client::AbstractInterface'
+ mainiface = self.mainiface or 'Telepathy::AbstractInterface'
if mainiface != self.namespace + '::' + name:
self.h("""
@@ -255,12 +255,12 @@ public:
self.b("""
%(name)s::%(name)s(const %(mainiface)s& mainInterface)
- : Telepathy::Client::AbstractInterface(mainInterface.service(), mainInterface.path(), staticInterfaceName(), mainInterface.connection(), mainInterface.parent())
+ : Telepathy::AbstractInterface(mainInterface.service(), mainInterface.path(), staticInterfaceName(), mainInterface.connection(), mainInterface.parent())
{
}
%(name)s::%(name)s(const %(mainiface)s& mainInterface, QObject *parent)
- : Telepathy::Client::AbstractInterface(mainInterface.service(), mainInterface.path(), staticInterfaceName(), mainInterface.connection(), parent)
+ : Telepathy::AbstractInterface(mainInterface.service(), mainInterface.path(), staticInterfaceName(), mainInterface.connection(), parent)
{
}
""" % {'name' : name,
@@ -301,11 +301,11 @@ Q_SIGNALS:\
# specific signals in order to remove its signal match rules)
self.h("""
protected:
- virtual void invalidate(Telepathy::Client::DBusProxy *, const QString &, const QString &);
+ virtual void invalidate(Telepathy::DBusProxy *, const QString &, const QString &);
""")
self.b("""
-void %(name)s::invalidate(Telepathy::Client::DBusProxy *proxy,
+void %(name)s::invalidate(Telepathy::DBusProxy *proxy,
const QString &error, const QString &message)
{
""" % {'name' : name})
@@ -314,7 +314,7 @@ void %(name)s::invalidate(Telepathy::Client::DBusProxy *proxy,
self.do_signal_disconnect(signal)
self.b("""
- Telepathy::Client::AbstractInterface::invalidate(proxy, error, message);
+ Telepathy::AbstractInterface::invalidate(proxy, error, message);
}
""")
--
1.5.6.5
More information about the telepathy-commits
mailing list