| Home · All Classes · All Namespaces · Modules · Functions · Files

cli-connection.h

    00001 /*
    00002  * This file contains D-Bus client proxy classes generated by qt-client-gen.py.
    00003  *
    00004  * This file can be distributed under the same terms as the specification from
    00005  * which it was generated.
    00006  */
    00007
    00008 #ifndef IN_TP_QT_HEADER
    00009 #error IN_TP_QT_HEADER
    00010 #endif
    00011
    00012 #include <TelepathyQt/Types>
    00013
    00014 #include <QtGlobal>
    00015
    00016 #include <QString>
    00017 #include <QObject>
    00018 #include <QVariant>
    00019
    00020 #include <QDBusPendingReply>
    00021
    00022 #include <TelepathyQt/AbstractInterface>
    00023 #include <TelepathyQt/DBusProxy>
    00024 #include <TelepathyQt/Global>
    00025
    00026 namespace Tp
    00027 {
    00028 class PendingVariant;
    00029 class PendingOperation;
    00030 }
    00031
    00032 namespace Tp
    00033 {
    00034 namespace Client
    00035 {
    00036
    00044 class TP_QT_EXPORT ConnectionInterface : public Tp::AbstractInterface
    00045 {
    00046     Q_OBJECT
    00047
    00048 public:
    00055     static inline QLatin1String staticInterfaceName()
    00056     {
    00057         return QLatin1String("org.freedesktop.Telepathy.Connection");
    00058     }
    00059
    00067     ConnectionInterface(
    00068         const QString& busName,
    00069         const QString& objectPath,
    00070         QObject* parent = 0
    00071     );
    00072
    00081     ConnectionInterface(
    00082         const QDBusConnection& connection,
    00083         const QString& busName,
    00084         const QString& objectPath,
    00085         QObject* parent = 0
    00086     );
    00087
    00094     ConnectionInterface(Tp::DBusProxy *proxy);
    00095
    00127     inline Tp::PendingVariant *requestPropertyInterfaces() const
    00128     {
    00129         return internalRequestProperty(QLatin1String("Interfaces"));
    00130     }
    00131
    00145     inline Tp::PendingVariant *requestPropertySelfHandle() const
    00146     {
    00147         return internalRequestProperty(QLatin1String("SelfHandle"));
    00148     }
    00149
    00168     inline Tp::PendingVariant *requestPropertyStatus() const
    00169     {
    00170         return internalRequestProperty(QLatin1String("Status"));
    00171     }
    00172
    00187     inline Tp::PendingVariant *requestPropertyHasImmortalHandles() const
    00188     {
    00189         return internalRequestProperty(QLatin1String("HasImmortalHandles"));
    00190     }
    00191
    00198     Tp::PendingVariantMap *requestAllProperties() const
    00199     {
    00200         return internalRequestAllProperties();
    00201     }
    00202
    00203 public Q_SLOTS:
    00221     inline QDBusPendingReply<> Connect(int timeout = -1)
    00222     {
    00223         if (!invalidationReason().isEmpty()) {
    00224             return QDBusPendingReply<>(QDBusMessage::createError(
    00225                 invalidationReason(),
    00226                 invalidationMessage()
    00227             ));
    00228         }
    00229
    00230         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00231                 this->staticInterfaceName(), QLatin1String("Connect"));
    00232         return this->connection().asyncCall(callMessage, timeout);
    00233     }
    00234
    00247     inline QDBusPendingReply<> Disconnect(int timeout = -1)
    00248     {
    00249         if (!invalidationReason().isEmpty()) {
    00250             return QDBusPendingReply<>(QDBusMessage::createError(
    00251                 invalidationReason(),
    00252                 invalidationMessage()
    00253             ));
    00254         }
    00255
    00256         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00257                 this->staticInterfaceName(), QLatin1String("Disconnect"));
    00258         return this->connection().asyncCall(callMessage, timeout);
    00259     }
    00260
    00279     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
    00280     {
    00281         if (!invalidationReason().isEmpty()) {
    00282             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    00283                 invalidationReason(),
    00284                 invalidationMessage()
    00285             ));
    00286         }
    00287
    00288         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00289                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
    00290         return this->connection().asyncCall(callMessage, timeout);
    00291     }
    00292
    00307     inline QDBusPendingReply<QString> GetProtocol(int timeout = -1)
    00308     {
    00309         if (!invalidationReason().isEmpty()) {
    00310             return QDBusPendingReply<QString>(QDBusMessage::createError(
    00311                 invalidationReason(),
    00312                 invalidationMessage()
    00313             ));
    00314         }
    00315
    00316         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00317                 this->staticInterfaceName(), QLatin1String("GetProtocol"));
    00318         return this->connection().asyncCall(callMessage, timeout);
    00319     }
    00320
    00336     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
    00337     {
    00338         if (!invalidationReason().isEmpty()) {
    00339             return QDBusPendingReply<uint>(QDBusMessage::createError(
    00340                 invalidationReason(),
    00341                 invalidationMessage()
    00342             ));
    00343         }
    00344
    00345         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00346                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
    00347         return this->connection().asyncCall(callMessage, timeout);
    00348     }
    00349
    00364     inline QDBusPendingReply<uint> GetStatus(int timeout = -1)
    00365     {
    00366         if (!invalidationReason().isEmpty()) {
    00367             return QDBusPendingReply<uint>(QDBusMessage::createError(
    00368                 invalidationReason(),
    00369                 invalidationMessage()
    00370             ));
    00371         }
    00372
    00373         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00374                 this->staticInterfaceName(), QLatin1String("GetStatus"));
    00375         return this->connection().asyncCall(callMessage, timeout);
    00376     }
    00377
    00420     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
    00421     {
    00422         if (!invalidationReason().isEmpty()) {
    00423             return QDBusPendingReply<>(QDBusMessage::createError(
    00424                 invalidationReason(),
    00425                 invalidationMessage()
    00426             ));
    00427         }
    00428
    00429         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00430                 this->staticInterfaceName(), QLatin1String("HoldHandles"));
    00431         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
    00432         return this->connection().asyncCall(callMessage, timeout);
    00433     }
    00434
    00458     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
    00459     {
    00460         if (!invalidationReason().isEmpty()) {
    00461             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    00462                 invalidationReason(),
    00463                 invalidationMessage()
    00464             ));
    00465         }
    00466
    00467         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00468                 this->staticInterfaceName(), QLatin1String("InspectHandles"));
    00469         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
    00470         return this->connection().asyncCall(callMessage, timeout);
    00471     }
    00472
    00487     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels(int timeout = -1)
    00488     {
    00489         if (!invalidationReason().isEmpty()) {
    00490             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
    00491                 invalidationReason(),
    00492                 invalidationMessage()
    00493             ));
    00494         }
    00495
    00496         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00497                 this->staticInterfaceName(), QLatin1String("ListChannels"));
    00498         return this->connection().asyncCall(callMessage, timeout);
    00499     }
    00500
    00526     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
    00527     {
    00528         if (!invalidationReason().isEmpty()) {
    00529             return QDBusPendingReply<>(QDBusMessage::createError(
    00530                 invalidationReason(),
    00531                 invalidationMessage()
    00532             ));
    00533         }
    00534
    00535         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00536                 this->staticInterfaceName(), QLatin1String("ReleaseHandles"));
    00537         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
    00538         return this->connection().asyncCall(callMessage, timeout);
    00539     }
    00540
    00620     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
    00621     {
    00622         if (!invalidationReason().isEmpty()) {
    00623             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
    00624                 invalidationReason(),
    00625                 invalidationMessage()
    00626             ));
    00627         }
    00628
    00629         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00630                 this->staticInterfaceName(), QLatin1String("RequestChannel"));
    00631         callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
    00632         return this->connection().asyncCall(callMessage, timeout);
    00633     }
    00634
    00675     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
    00676     {
    00677         if (!invalidationReason().isEmpty()) {
    00678             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    00679                 invalidationReason(),
    00680                 invalidationMessage()
    00681             ));
    00682         }
    00683
    00684         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00685                 this->staticInterfaceName(), QLatin1String("RequestHandles"));
    00686         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
    00687         return this->connection().asyncCall(callMessage, timeout);
    00688     }
    00689
    00783     inline QDBusPendingReply<> AddClientInterest(const QStringList& tokens, int timeout = -1)
    00784     {
    00785         if (!invalidationReason().isEmpty()) {
    00786             return QDBusPendingReply<>(QDBusMessage::createError(
    00787                 invalidationReason(),
    00788                 invalidationMessage()
    00789             ));
    00790         }
    00791
    00792         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00793                 this->staticInterfaceName(), QLatin1String("AddClientInterest"));
    00794         callMessage << QVariant::fromValue(tokens);
    00795         return this->connection().asyncCall(callMessage, timeout);
    00796     }
    00797
    00829     inline QDBusPendingReply<> RemoveClientInterest(const QStringList& tokens, int timeout = -1)
    00830     {
    00831         if (!invalidationReason().isEmpty()) {
    00832             return QDBusPendingReply<>(QDBusMessage::createError(
    00833                 invalidationReason(),
    00834                 invalidationMessage()
    00835             ));
    00836         }
    00837
    00838         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    00839                 this->staticInterfaceName(), QLatin1String("RemoveClientInterest"));
    00840         callMessage << QVariant::fromValue(tokens);
    00841         return this->connection().asyncCall(callMessage, timeout);
    00842     }
    00843
    00844 Q_SIGNALS:
    00856     void SelfHandleChanged(uint selfHandle);
    00857
    00901     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
    00902
    00972     void ConnectionError(const QString& error, const QVariantMap& details);
    00973
    00990     void StatusChanged(uint status, uint reason);
    00991
    00992 protected:
    00993     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    00994 };
    00995
    01003 class TP_QT_EXPORT ConnectionInterfaceAddressingInterface : public Tp::AbstractInterface
    01004 {
    01005     Q_OBJECT
    01006
    01007 public:
    01014     static inline QLatin1String staticInterfaceName()
    01015     {
    01016         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Addressing1");
    01017     }
    01018
    01026     ConnectionInterfaceAddressingInterface(
    01027         const QString& busName,
    01028         const QString& objectPath,
    01029         QObject* parent = 0
    01030     );
    01031
    01040     ConnectionInterfaceAddressingInterface(
    01041         const QDBusConnection& connection,
    01042         const QString& busName,
    01043         const QString& objectPath,
    01044         QObject* parent = 0
    01045     );
    01046
    01053     ConnectionInterfaceAddressingInterface(Tp::DBusProxy *proxy);
    01054
    01062     explicit ConnectionInterfaceAddressingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01063
    01071     ConnectionInterfaceAddressingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01072
    01079     Tp::PendingVariantMap *requestAllProperties() const
    01080     {
    01081         return internalRequestAllProperties();
    01082     }
    01083
    01084 public Q_SLOTS:
    01174     inline QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap> GetContactsByVCardField(const QString& field, const QStringList& addresses, const QStringList& interfaces, int timeout = -1)
    01175     {
    01176         if (!invalidationReason().isEmpty()) {
    01177             return QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap>(QDBusMessage::createError(
    01178                 invalidationReason(),
    01179                 invalidationMessage()
    01180             ));
    01181         }
    01182
    01183         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01184                 this->staticInterfaceName(), QLatin1String("GetContactsByVCardField"));
    01185         callMessage << QVariant::fromValue(field) << QVariant::fromValue(addresses) << QVariant::fromValue(interfaces);
    01186         return this->connection().asyncCall(callMessage, timeout);
    01187     }
    01188
    01259     inline QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap> GetContactsByURI(const QStringList& URIs, const QStringList& interfaces, int timeout = -1)
    01260     {
    01261         if (!invalidationReason().isEmpty()) {
    01262             return QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap>(QDBusMessage::createError(
    01263                 invalidationReason(),
    01264                 invalidationMessage()
    01265             ));
    01266         }
    01267
    01268         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01269                 this->staticInterfaceName(), QLatin1String("GetContactsByURI"));
    01270         callMessage << QVariant::fromValue(URIs) << QVariant::fromValue(interfaces);
    01271         return this->connection().asyncCall(callMessage, timeout);
    01272     }
    01273
    01274 protected:
    01275     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01276 };
    01277
    01285 class TP_QT_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
    01286 {
    01287     Q_OBJECT
    01288
    01289 public:
    01296     static inline QLatin1String staticInterfaceName()
    01297     {
    01298         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
    01299     }
    01300
    01308     ConnectionInterfaceAliasingInterface(
    01309         const QString& busName,
    01310         const QString& objectPath,
    01311         QObject* parent = 0
    01312     );
    01313
    01322     ConnectionInterfaceAliasingInterface(
    01323         const QDBusConnection& connection,
    01324         const QString& busName,
    01325         const QString& objectPath,
    01326         QObject* parent = 0
    01327     );
    01328
    01335     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
    01336
    01344     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01345
    01353     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01354
    01361     Tp::PendingVariantMap *requestAllProperties() const
    01362     {
    01363         return internalRequestAllProperties();
    01364     }
    01365
    01366 public Q_SLOTS:
    01382     inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
    01383     {
    01384         if (!invalidationReason().isEmpty()) {
    01385             return QDBusPendingReply<uint>(QDBusMessage::createError(
    01386                 invalidationReason(),
    01387                 invalidationMessage()
    01388             ));
    01389         }
    01390
    01391         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01392                 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
    01393         return this->connection().asyncCall(callMessage, timeout);
    01394     }
    01395
    01414     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
    01415     {
    01416         if (!invalidationReason().isEmpty()) {
    01417             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    01418                 invalidationReason(),
    01419                 invalidationMessage()
    01420             ));
    01421         }
    01422
    01423         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01424                 this->staticInterfaceName(), QLatin1String("RequestAliases"));
    01425         callMessage << QVariant::fromValue(contacts);
    01426         return this->connection().asyncCall(callMessage, timeout);
    01427     }
    01428
    01451     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
    01452     {
    01453         if (!invalidationReason().isEmpty()) {
    01454             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
    01455                 invalidationReason(),
    01456                 invalidationMessage()
    01457             ));
    01458         }
    01459
    01460         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01461                 this->staticInterfaceName(), QLatin1String("GetAliases"));
    01462         callMessage << QVariant::fromValue(contacts);
    01463         return this->connection().asyncCall(callMessage, timeout);
    01464     }
    01465
    01485     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
    01486     {
    01487         if (!invalidationReason().isEmpty()) {
    01488             return QDBusPendingReply<>(QDBusMessage::createError(
    01489                 invalidationReason(),
    01490                 invalidationMessage()
    01491             ));
    01492         }
    01493
    01494         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01495                 this->staticInterfaceName(), QLatin1String("SetAliases"));
    01496         callMessage << QVariant::fromValue(aliases);
    01497         return this->connection().asyncCall(callMessage, timeout);
    01498     }
    01499
    01500 Q_SIGNALS:
    01517     void AliasesChanged(const Tp::AliasPairList& aliases);
    01518
    01519 protected:
    01520     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01521 };
    01522
    01530 class TP_QT_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
    01531 {
    01532     Q_OBJECT
    01533
    01534 public:
    01541     static inline QLatin1String staticInterfaceName()
    01542     {
    01543         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
    01544     }
    01545
    01553     ConnectionInterfaceAnonymityInterface(
    01554         const QString& busName,
    01555         const QString& objectPath,
    01556         QObject* parent = 0
    01557     );
    01558
    01567     ConnectionInterfaceAnonymityInterface(
    01568         const QDBusConnection& connection,
    01569         const QString& busName,
    01570         const QString& objectPath,
    01571         QObject* parent = 0
    01572     );
    01573
    01580     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
    01581
    01589     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01590
    01598     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01599
    01610     inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
    01611     {
    01612         return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
    01613     }
    01614
    01630     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
    01631     {
    01632         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
    01633     }
    01634
    01650     inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
    01651     {
    01652         return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
    01653     }
    01654
    01667     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
    01668     {
    01669         return internalRequestProperty(QLatin1String("AnonymityModes"));
    01670     }
    01671
    01684     inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
    01685     {
    01686         return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
    01687     }
    01688
    01695     Tp::PendingVariantMap *requestAllProperties() const
    01696     {
    01697         return internalRequestAllProperties();
    01698     }
    01699
    01700 Q_SIGNALS:
    01710     void AnonymityModesChanged(uint modes);
    01711
    01712 protected:
    01713     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01714 };
    01715
    01723 class TP_QT_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
    01724 {
    01725     Q_OBJECT
    01726
    01727 public:
    01734     static inline QLatin1String staticInterfaceName()
    01735     {
    01736         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
    01737     }
    01738
    01746     ConnectionInterfaceAvatarsInterface(
    01747         const QString& busName,
    01748         const QString& objectPath,
    01749         QObject* parent = 0
    01750     );
    01751
    01760     ConnectionInterfaceAvatarsInterface(
    01761         const QDBusConnection& connection,
    01762         const QString& busName,
    01763         const QString& objectPath,
    01764         QObject* parent = 0
    01765     );
    01766
    01773     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
    01774
    01782     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01783
    01791     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01792
    01804     inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
    01805     {
    01806         return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
    01807     }
    01808
    01820     inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
    01821     {
    01822         return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
    01823     }
    01824
    01836     inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
    01837     {
    01838         return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
    01839     }
    01840
    01855     inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
    01856     {
    01857         return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
    01858     }
    01859
    01872     inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
    01873     {
    01874         return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
    01875     }
    01876
    01888     inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
    01889     {
    01890         return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
    01891     }
    01892
    01904     inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
    01905     {
    01906         return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
    01907     }
    01908
    01920     inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
    01921     {
    01922         return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
    01923     }
    01924
    01931     Tp::PendingVariantMap *requestAllProperties() const
    01932     {
    01933         return internalRequestAllProperties();
    01934     }
    01935
    01936 public Q_SLOTS:
    01971     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
    01972     {
    01973         if (!invalidationReason().isEmpty()) {
    01974             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
    01975                 invalidationReason(),
    01976                 invalidationMessage()
    01977             ));
    01978         }
    01979
    01980         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01981                 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
    01982         return this->connection().asyncCall(callMessage, timeout);
    01983     }
    01984
    02006     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
    02007     {
    02008         if (!invalidationReason().isEmpty()) {
    02009             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    02010                 invalidationReason(),
    02011                 invalidationMessage()
    02012             ));
    02013         }
    02014
    02015         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02016                 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
    02017         callMessage << QVariant::fromValue(contacts);
    02018         return this->connection().asyncCall(callMessage, timeout);
    02019     }
    02020
    02048     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
    02049     {
    02050         if (!invalidationReason().isEmpty()) {
    02051             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
    02052                 invalidationReason(),
    02053                 invalidationMessage()
    02054             ));
    02055         }
    02056
    02057         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02058                 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
    02059         callMessage << QVariant::fromValue(contacts);
    02060         return this->connection().asyncCall(callMessage, timeout);
    02061     }
    02062
    02087     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
    02088     {
    02089         if (!invalidationReason().isEmpty()) {
    02090             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
    02091                 invalidationReason(),
    02092                 invalidationMessage()
    02093             ));
    02094         }
    02095
    02096         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02097                 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
    02098         callMessage << QVariant::fromValue(contact);
    02099         return this->connection().asyncCall(callMessage, timeout);
    02100     }
    02101
    02120     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
    02121     {
    02122         if (!invalidationReason().isEmpty()) {
    02123             return QDBusPendingReply<>(QDBusMessage::createError(
    02124                 invalidationReason(),
    02125                 invalidationMessage()
    02126             ));
    02127         }
    02128
    02129         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02130                 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
    02131         callMessage << QVariant::fromValue(contacts);
    02132         return this->connection().asyncCall(callMessage, timeout);
    02133     }
    02134
    02158     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
    02159     {
    02160         if (!invalidationReason().isEmpty()) {
    02161             return QDBusPendingReply<QString>(QDBusMessage::createError(
    02162                 invalidationReason(),
    02163                 invalidationMessage()
    02164             ));
    02165         }
    02166
    02167         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02168                 this->staticInterfaceName(), QLatin1String("SetAvatar"));
    02169         callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
    02170         return this->connection().asyncCall(callMessage, timeout);
    02171     }
    02172
    02183     inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
    02184     {
    02185         if (!invalidationReason().isEmpty()) {
    02186             return QDBusPendingReply<>(QDBusMessage::createError(
    02187                 invalidationReason(),
    02188                 invalidationMessage()
    02189             ));
    02190         }
    02191
    02192         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02193                 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
    02194         return this->connection().asyncCall(callMessage, timeout);
    02195     }
    02196
    02197 Q_SIGNALS:
    02214     void AvatarUpdated(uint contact, const QString& newAvatarToken);
    02215
    02238     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
    02239
    02240 protected:
    02241     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02242 };
    02243
    02251 class TP_QT_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
    02252 {
    02253     Q_OBJECT
    02254
    02255 public:
    02262     static inline QLatin1String staticInterfaceName()
    02263     {
    02264         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
    02265     }
    02266
    02274     ConnectionInterfaceBalanceInterface(
    02275         const QString& busName,
    02276         const QString& objectPath,
    02277         QObject* parent = 0
    02278     );
    02279
    02288     ConnectionInterfaceBalanceInterface(
    02289         const QDBusConnection& connection,
    02290         const QString& busName,
    02291         const QString& objectPath,
    02292         QObject* parent = 0
    02293     );
    02294
    02301     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
    02302
    02310     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02311
    02319     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02320
    02339     inline Tp::PendingVariant *requestPropertyAccountBalance() const
    02340     {
    02341         return internalRequestProperty(QLatin1String("AccountBalance"));
    02342     }
    02343
    02361     inline Tp::PendingVariant *requestPropertyManageCreditURI() const
    02362     {
    02363         return internalRequestProperty(QLatin1String("ManageCreditURI"));
    02364     }
    02365
    02372     Tp::PendingVariantMap *requestAllProperties() const
    02373     {
    02374         return internalRequestAllProperties();
    02375     }
    02376
    02377 Q_SIGNALS:
    02392     void BalanceChanged(const Tp::CurrencyAmount& balance);
    02393
    02394 protected:
    02395     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02396 };
    02397
    02405 class TP_QT_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
    02406 {
    02407     Q_OBJECT
    02408
    02409 public:
    02416     static inline QLatin1String staticInterfaceName()
    02417     {
    02418         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
    02419     }
    02420
    02428     ConnectionInterfaceCapabilitiesInterface(
    02429         const QString& busName,
    02430         const QString& objectPath,
    02431         QObject* parent = 0
    02432     );
    02433
    02442     ConnectionInterfaceCapabilitiesInterface(
    02443         const QDBusConnection& connection,
    02444         const QString& busName,
    02445         const QString& objectPath,
    02446         QObject* parent = 0
    02447     );
    02448
    02455     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
    02456
    02464     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02465
    02473     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02474
    02481     Tp::PendingVariantMap *requestAllProperties() const
    02482     {
    02483         return internalRequestAllProperties();
    02484     }
    02485
    02486 public Q_SLOTS:
    02540     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
    02541     {
    02542         if (!invalidationReason().isEmpty()) {
    02543             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
    02544                 invalidationReason(),
    02545                 invalidationMessage()
    02546             ));
    02547         }
    02548
    02549         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02550                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
    02551         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
    02552         return this->connection().asyncCall(callMessage, timeout);
    02553     }
    02554
    02589     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
    02590     {
    02591         if (!invalidationReason().isEmpty()) {
    02592             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
    02593                 invalidationReason(),
    02594                 invalidationMessage()
    02595             ));
    02596         }
    02597
    02598         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02599                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
    02600         callMessage << QVariant::fromValue(handles);
    02601         return this->connection().asyncCall(callMessage, timeout);
    02602     }
    02603
    02604 Q_SIGNALS:
    02631     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
    02632
    02633 protected:
    02634     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02635 };
    02636
    02644 class TP_QT_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
    02645 {
    02646     Q_OBJECT
    02647
    02648 public:
    02655     static inline QLatin1String staticInterfaceName()
    02656     {
    02657         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
    02658     }
    02659
    02667     ConnectionInterfaceCellularInterface(
    02668         const QString& busName,
    02669         const QString& objectPath,
    02670         QObject* parent = 0
    02671     );
    02672
    02681     ConnectionInterfaceCellularInterface(
    02682         const QDBusConnection& connection,
    02683         const QString& busName,
    02684         const QString& objectPath,
    02685         QObject* parent = 0
    02686     );
    02687
    02694     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
    02695
    02703     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02704
    02712     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02713
    02732     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
    02733     {
    02734         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
    02735     }
    02736
    02755     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
    02756     {
    02757         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
    02758     }
    02759
    02782     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
    02783     {
    02784         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
    02785     }
    02786
    02809     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
    02810     {
    02811         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
    02812     }
    02813
    02830     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
    02831     {
    02832         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
    02833     }
    02834
    02851     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
    02852     {
    02853         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
    02854     }
    02855
    02869     inline Tp::PendingVariant *requestPropertyIMSI() const
    02870     {
    02871         return internalRequestProperty(QLatin1String("IMSI"));
    02872     }
    02873
    02892     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
    02893     {
    02894         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
    02895     }
    02896
    02915     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
    02916     {
    02917         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
    02918     }
    02919
    02945     inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
    02946     {
    02947         return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
    02948     }
    02949
    02975     inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
    02976     {
    02977         return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
    02978     }
    02979
    02986     Tp::PendingVariantMap *requestAllProperties() const
    02987     {
    02988         return internalRequestAllProperties();
    02989     }
    02990
    02991 Q_SIGNALS:
    03007     void IMSIChanged(const QString& IMSI);
    03008
    03009 protected:
    03010     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03011 };
    03012
    03020 class TP_QT_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
    03021 {
    03022     Q_OBJECT
    03023
    03024 public:
    03031     static inline QLatin1String staticInterfaceName()
    03032     {
    03033         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
    03034     }
    03035
    03043     ConnectionInterfaceClientTypesInterface(
    03044         const QString& busName,
    03045         const QString& objectPath,
    03046         QObject* parent = 0
    03047     );
    03048
    03057     ConnectionInterfaceClientTypesInterface(
    03058         const QDBusConnection& connection,
    03059         const QString& busName,
    03060         const QString& objectPath,
    03061         QObject* parent = 0
    03062     );
    03063
    03070     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
    03071
    03079     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03080
    03088     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03089
    03096     Tp::PendingVariantMap *requestAllProperties() const
    03097     {
    03098         return internalRequestAllProperties();
    03099     }
    03100
    03101 public Q_SLOTS:
    03130     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
    03131     {
    03132         if (!invalidationReason().isEmpty()) {
    03133             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
    03134                 invalidationReason(),
    03135                 invalidationMessage()
    03136             ));
    03137         }
    03138
    03139         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03140                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
    03141         callMessage << QVariant::fromValue(contacts);
    03142         return this->connection().asyncCall(callMessage, timeout);
    03143     }
    03144
    03169     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
    03170     {
    03171         if (!invalidationReason().isEmpty()) {
    03172             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    03173                 invalidationReason(),
    03174                 invalidationMessage()
    03175             ));
    03176         }
    03177
    03178         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03179                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
    03180         callMessage << QVariant::fromValue(contact);
    03181         return this->connection().asyncCall(callMessage, timeout);
    03182     }
    03183
    03184 Q_SIGNALS:
    03199     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
    03200
    03201 protected:
    03202     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03203 };
    03204
    03212 class TP_QT_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
    03213 {
    03214     Q_OBJECT
    03215
    03216 public:
    03223     static inline QLatin1String staticInterfaceName()
    03224     {
    03225         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
    03226     }
    03227
    03235     ConnectionInterfaceContactBlockingInterface(
    03236         const QString& busName,
    03237         const QString& objectPath,
    03238         QObject* parent = 0
    03239     );
    03240
    03249     ConnectionInterfaceContactBlockingInterface(
    03250         const QDBusConnection& connection,
    03251         const QString& busName,
    03252         const QString& objectPath,
    03253         QObject* parent = 0
    03254     );
    03255
    03262     ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
    03263
    03271     explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03272
    03280     ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03281
    03298     inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
    03299     {
    03300         return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
    03301     }
    03302
    03309     Tp::PendingVariantMap *requestAllProperties() const
    03310     {
    03311         return internalRequestAllProperties();
    03312     }
    03313
    03314 public Q_SLOTS:
    03374     inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
    03375     {
    03376         if (!invalidationReason().isEmpty()) {
    03377             return QDBusPendingReply<>(QDBusMessage::createError(
    03378                 invalidationReason(),
    03379                 invalidationMessage()
    03380             ));
    03381         }
    03382
    03383         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03384                 this->staticInterfaceName(), QLatin1String("BlockContacts"));
    03385         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
    03386         return this->connection().asyncCall(callMessage, timeout);
    03387     }
    03388
    03407     inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
    03408     {
    03409         if (!invalidationReason().isEmpty()) {
    03410             return QDBusPendingReply<>(QDBusMessage::createError(
    03411                 invalidationReason(),
    03412                 invalidationMessage()
    03413             ));
    03414         }
    03415
    03416         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03417                 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
    03418         callMessage << QVariant::fromValue(contacts);
    03419         return this->connection().asyncCall(callMessage, timeout);
    03420     }
    03421
    03442     inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
    03443     {
    03444         if (!invalidationReason().isEmpty()) {
    03445             return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
    03446                 invalidationReason(),
    03447                 invalidationMessage()
    03448             ));
    03449         }
    03450
    03451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03452                 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
    03453         return this->connection().asyncCall(callMessage, timeout);
    03454     }
    03455
    03456 Q_SIGNALS:
    03475     void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
    03476
    03477 protected:
    03478     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03479 };
    03480
    03488 class TP_QT_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
    03489 {
    03490     Q_OBJECT
    03491
    03492 public:
    03499     static inline QLatin1String staticInterfaceName()
    03500     {
    03501         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
    03502     }
    03503
    03511     ConnectionInterfaceContactCapabilitiesInterface(
    03512         const QString& busName,
    03513         const QString& objectPath,
    03514         QObject* parent = 0
    03515     );
    03516
    03525     ConnectionInterfaceContactCapabilitiesInterface(
    03526         const QDBusConnection& connection,
    03527         const QString& busName,
    03528         const QString& objectPath,
    03529         QObject* parent = 0
    03530     );
    03531
    03538     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
    03539
    03547     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03548
    03556     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03557
    03564     Tp::PendingVariantMap *requestAllProperties() const
    03565     {
    03566         return internalRequestAllProperties();
    03567     }
    03568
    03569 public Q_SLOTS:
    03632     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
    03633     {
    03634         if (!invalidationReason().isEmpty()) {
    03635             return QDBusPendingReply<>(QDBusMessage::createError(
    03636                 invalidationReason(),
    03637                 invalidationMessage()
    03638             ));
    03639         }
    03640
    03641         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03642                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
    03643         callMessage << QVariant::fromValue(handlerCapabilities);
    03644         return this->connection().asyncCall(callMessage, timeout);
    03645     }
    03646
    03682     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
    03683     {
    03684         if (!invalidationReason().isEmpty()) {
    03685             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
    03686                 invalidationReason(),
    03687                 invalidationMessage()
    03688             ));
    03689         }
    03690
    03691         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03692                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
    03693         callMessage << QVariant::fromValue(handles);
    03694         return this->connection().asyncCall(callMessage, timeout);
    03695     }
    03696
    03697 Q_SIGNALS:
    03718     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
    03719
    03720 protected:
    03721     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03722 };
    03723
    03731 class TP_QT_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
    03732 {
    03733     Q_OBJECT
    03734
    03735 public:
    03742     static inline QLatin1String staticInterfaceName()
    03743     {
    03744         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
    03745     }
    03746
    03754     ConnectionInterfaceContactGroupsInterface(
    03755         const QString& busName,
    03756         const QString& objectPath,
    03757         QObject* parent = 0
    03758     );
    03759
    03768     ConnectionInterfaceContactGroupsInterface(
    03769         const QDBusConnection& connection,
    03770         const QString& busName,
    03771         const QString& objectPath,
    03772         QObject* parent = 0
    03773     );
    03774
    03781     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
    03782
    03790     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03791
    03799     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03800
    03817     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
    03818     {
    03819         return internalRequestProperty(QLatin1String("DisjointGroups"));
    03820     }
    03821
    03834     inline Tp::PendingVariant *requestPropertyGroupStorage() const
    03835     {
    03836         return internalRequestProperty(QLatin1String("GroupStorage"));
    03837     }
    03838
    03862     inline Tp::PendingVariant *requestPropertyGroups() const
    03863     {
    03864         return internalRequestProperty(QLatin1String("Groups"));
    03865     }
    03866
    03873     Tp::PendingVariantMap *requestAllProperties() const
    03874     {
    03875         return internalRequestAllProperties();
    03876     }
    03877
    03878 public Q_SLOTS:
    03927     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
    03928     {
    03929         if (!invalidationReason().isEmpty()) {
    03930             return QDBusPendingReply<>(QDBusMessage::createError(
    03931                 invalidationReason(),
    03932                 invalidationMessage()
    03933             ));
    03934         }
    03935
    03936         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03937                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
    03938         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
    03939         return this->connection().asyncCall(callMessage, timeout);
    03940     }
    03941
    03989     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03990     {
    03991         if (!invalidationReason().isEmpty()) {
    03992             return QDBusPendingReply<>(QDBusMessage::createError(
    03993                 invalidationReason(),
    03994                 invalidationMessage()
    03995             ));
    03996         }
    03997
    03998         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03999                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
    04000         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    04001         return this->connection().asyncCall(callMessage, timeout);
    04002     }
    04003
    04044     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
    04045     {
    04046         if (!invalidationReason().isEmpty()) {
    04047             return QDBusPendingReply<>(QDBusMessage::createError(
    04048                 invalidationReason(),
    04049                 invalidationMessage()
    04050             ));
    04051         }
    04052
    04053         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04054                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
    04055         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    04056         return this->connection().asyncCall(callMessage, timeout);
    04057     }
    04058
    04098     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
    04099     {
    04100         if (!invalidationReason().isEmpty()) {
    04101             return QDBusPendingReply<>(QDBusMessage::createError(
    04102                 invalidationReason(),
    04103                 invalidationMessage()
    04104             ));
    04105         }
    04106
    04107         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04108                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
    04109         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    04110         return this->connection().asyncCall(callMessage, timeout);
    04111     }
    04112
    04141     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
    04142     {
    04143         if (!invalidationReason().isEmpty()) {
    04144             return QDBusPendingReply<>(QDBusMessage::createError(
    04145                 invalidationReason(),
    04146                 invalidationMessage()
    04147             ));
    04148         }
    04149
    04150         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04151                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
    04152         callMessage << QVariant::fromValue(group);
    04153         return this->connection().asyncCall(callMessage, timeout);
    04154     }
    04155
    04195     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
    04196     {
    04197         if (!invalidationReason().isEmpty()) {
    04198             return QDBusPendingReply<>(QDBusMessage::createError(
    04199                 invalidationReason(),
    04200                 invalidationMessage()
    04201             ));
    04202         }
    04203
    04204         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04205                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
    04206         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
    04207         return this->connection().asyncCall(callMessage, timeout);
    04208     }
    04209
    04210 Q_SIGNALS:
    04228     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
    04229
    04240     void GroupsCreated(const QStringList& names);
    04241
    04289     void GroupRenamed(const QString& oldName, const QString& newName);
    04290
    04317     void GroupsRemoved(const QStringList& names);
    04318
    04319 protected:
    04320     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04321 };
    04322
    04330 class TP_QT_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
    04331 {
    04332     Q_OBJECT
    04333
    04334 public:
    04341     static inline QLatin1String staticInterfaceName()
    04342     {
    04343         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
    04344     }
    04345
    04353     ConnectionInterfaceContactInfoInterface(
    04354         const QString& busName,
    04355         const QString& objectPath,
    04356         QObject* parent = 0
    04357     );
    04358
    04367     ConnectionInterfaceContactInfoInterface(
    04368         const QDBusConnection& connection,
    04369         const QString& busName,
    04370         const QString& objectPath,
    04371         QObject* parent = 0
    04372     );
    04373
    04380     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
    04381
    04389     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
    04390
    04398     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    04399
    04423     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
    04424     {
    04425         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
    04426     }
    04427
    04485     inline Tp::PendingVariant *requestPropertySupportedFields() const
    04486     {
    04487         return internalRequestProperty(QLatin1String("SupportedFields"));
    04488     }
    04489
    04496     Tp::PendingVariantMap *requestAllProperties() const
    04497     {
    04498         return internalRequestAllProperties();
    04499     }
    04500
    04501 public Q_SLOTS:
    04524     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    04525     {
    04526         if (!invalidationReason().isEmpty()) {
    04527             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
    04528                 invalidationReason(),
    04529                 invalidationMessage()
    04530             ));
    04531         }
    04532
    04533         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04534                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
    04535         callMessage << QVariant::fromValue(contacts);
    04536         return this->connection().asyncCall(callMessage, timeout);
    04537     }
    04538
    04558     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    04559     {
    04560         if (!invalidationReason().isEmpty()) {
    04561             return QDBusPendingReply<>(QDBusMessage::createError(
    04562                 invalidationReason(),
    04563                 invalidationMessage()
    04564             ));
    04565         }
    04566
    04567         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04568                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
    04569         callMessage << QVariant::fromValue(contacts);
    04570         return this->connection().asyncCall(callMessage, timeout);
    04571     }
    04572
    04594     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
    04595     {
    04596         if (!invalidationReason().isEmpty()) {
    04597             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
    04598                 invalidationReason(),
    04599                 invalidationMessage()
    04600             ));
    04601         }
    04602
    04603         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04604                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
    04605         callMessage << QVariant::fromValue(contact);
    04606         return this->connection().asyncCall(callMessage, timeout);
    04607     }
    04608
    04626     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
    04627     {
    04628         if (!invalidationReason().isEmpty()) {
    04629             return QDBusPendingReply<>(QDBusMessage::createError(
    04630                 invalidationReason(),
    04631                 invalidationMessage()
    04632             ));
    04633         }
    04634
    04635         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04636                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
    04637         callMessage << QVariant::fromValue(contactInfo);
    04638         return this->connection().asyncCall(callMessage, timeout);
    04639     }
    04640
    04641 Q_SIGNALS:
    04658     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
    04659
    04660 protected:
    04661     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04662 };
    04663
    04671 class TP_QT_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
    04672 {
    04673     Q_OBJECT
    04674
    04675 public:
    04682     static inline QLatin1String staticInterfaceName()
    04683     {
    04684         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
    04685     }
    04686
    04694     ConnectionInterfaceContactListInterface(
    04695         const QString& busName,
    04696         const QString& objectPath,
    04697         QObject* parent = 0
    04698     );
    04699
    04708     ConnectionInterfaceContactListInterface(
    04709         const QDBusConnection& connection,
    04710         const QString& busName,
    04711         const QString& objectPath,
    04712         QObject* parent = 0
    04713     );
    04714
    04721     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
    04722
    04730     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
    04731
    04739     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    04740
    04751     inline Tp::PendingVariant *requestPropertyContactListState() const
    04752     {
    04753         return internalRequestProperty(QLatin1String("ContactListState"));
    04754     }
    04755
    04815     inline Tp::PendingVariant *requestPropertyContactListPersists() const
    04816     {
    04817         return internalRequestProperty(QLatin1String("ContactListPersists"));
    04818     }
    04819
    04848     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
    04849     {
    04850         return internalRequestProperty(QLatin1String("CanChangeContactList"));
    04851     }
    04852
    04881     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
    04882     {
    04883         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
    04884     }
    04885
    04917     inline Tp::PendingVariant *requestPropertyDownloadAtConnection() const
    04918     {
    04919         return internalRequestProperty(QLatin1String("DownloadAtConnection"));
    04920     }
    04921
    04928     Tp::PendingVariantMap *requestAllProperties() const
    04929     {
    04930         return internalRequestAllProperties();
    04931     }
    04932
    04933 public Q_SLOTS:
    05005     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
    05006     {
    05007         if (!invalidationReason().isEmpty()) {
    05008             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    05009                 invalidationReason(),
    05010                 invalidationMessage()
    05011             ));
    05012         }
    05013
    05014         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05015                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
    05016         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    05017         return this->connection().asyncCall(callMessage, timeout);
    05018     }
    05019
    05130     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    05131     {
    05132         if (!invalidationReason().isEmpty()) {
    05133             return QDBusPendingReply<>(QDBusMessage::createError(
    05134                 invalidationReason(),
    05135                 invalidationMessage()
    05136             ));
    05137         }
    05138
    05139         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05140                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
    05141         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    05142         return this->connection().asyncCall(callMessage, timeout);
    05143     }
    05144
    05216     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
    05217     {
    05218         if (!invalidationReason().isEmpty()) {
    05219             return QDBusPendingReply<>(QDBusMessage::createError(
    05220                 invalidationReason(),
    05221                 invalidationMessage()
    05222             ));
    05223         }
    05224
    05225         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05226                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
    05227         callMessage << QVariant::fromValue(contacts);
    05228         return this->connection().asyncCall(callMessage, timeout);
    05229     }
    05230
    05280     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
    05281     {
    05282         if (!invalidationReason().isEmpty()) {
    05283             return QDBusPendingReply<>(QDBusMessage::createError(
    05284                 invalidationReason(),
    05285                 invalidationMessage()
    05286             ));
    05287         }
    05288
    05289         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05290                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
    05291         callMessage << QVariant::fromValue(contacts);
    05292         return this->connection().asyncCall(callMessage, timeout);
    05293     }
    05294
    05331     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
    05332     {
    05333         if (!invalidationReason().isEmpty()) {
    05334             return QDBusPendingReply<>(QDBusMessage::createError(
    05335                 invalidationReason(),
    05336                 invalidationMessage()
    05337             ));
    05338         }
    05339
    05340         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05341                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
    05342         callMessage << QVariant::fromValue(contacts);
    05343         return this->connection().asyncCall(callMessage, timeout);
    05344     }
    05345
    05382     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
    05383     {
    05384         if (!invalidationReason().isEmpty()) {
    05385             return QDBusPendingReply<>(QDBusMessage::createError(
    05386                 invalidationReason(),
    05387                 invalidationMessage()
    05388             ));
    05389         }
    05390
    05391         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05392                 this->staticInterfaceName(), QLatin1String("Unpublish"));
    05393         callMessage << QVariant::fromValue(contacts);
    05394         return this->connection().asyncCall(callMessage, timeout);
    05395     }
    05396
    05411     inline QDBusPendingReply<> Download(int timeout = -1)
    05412     {
    05413         if (!invalidationReason().isEmpty()) {
    05414             return QDBusPendingReply<>(QDBusMessage::createError(
    05415                 invalidationReason(),
    05416                 invalidationMessage()
    05417             ));
    05418         }
    05419
    05420         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05421                 this->staticInterfaceName(), QLatin1String("Download"));
    05422         return this->connection().asyncCall(callMessage, timeout);
    05423     }
    05424
    05425 Q_SIGNALS:
    05435     void ContactListStateChanged(uint contactListState);
    05436
    05487     void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
    05488
    05511     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
    05512
    05513 protected:
    05514     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05515 };
    05516
    05524 class TP_QT_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
    05525 {
    05526     Q_OBJECT
    05527
    05528 public:
    05535     static inline QLatin1String staticInterfaceName()
    05536     {
    05537         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
    05538     }
    05539
    05547     ConnectionInterfaceContactsInterface(
    05548         const QString& busName,
    05549         const QString& objectPath,
    05550         QObject* parent = 0
    05551     );
    05552
    05561     ConnectionInterfaceContactsInterface(
    05562         const QDBusConnection& connection,
    05563         const QString& busName,
    05564         const QString& objectPath,
    05565         QObject* parent = 0
    05566     );
    05567
    05574     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
    05575
    05583     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05584
    05592     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05593
    05604     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
    05605     {
    05606         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
    05607     }
    05608
    05615     Tp::PendingVariantMap *requestAllProperties() const
    05616     {
    05617         return internalRequestAllProperties();
    05618     }
    05619
    05620 public Q_SLOTS:
    05703     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
    05704     {
    05705         if (!invalidationReason().isEmpty()) {
    05706             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    05707                 invalidationReason(),
    05708                 invalidationMessage()
    05709             ));
    05710         }
    05711
    05712         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05713                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
    05714         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    05715         return this->connection().asyncCall(callMessage, timeout);
    05716     }
    05717
    05718 protected:
    05719     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05720 };
    05721
    05729 class TP_QT_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
    05730 {
    05731     Q_OBJECT
    05732
    05733 public:
    05740     static inline QLatin1String staticInterfaceName()
    05741     {
    05742         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
    05743     }
    05744
    05752     ConnectionInterfaceLocationInterface(
    05753         const QString& busName,
    05754         const QString& objectPath,
    05755         QObject* parent = 0
    05756     );
    05757
    05766     ConnectionInterfaceLocationInterface(
    05767         const QDBusConnection& connection,
    05768         const QString& busName,
    05769         const QString& objectPath,
    05770         QObject* parent = 0
    05771     );
    05772
    05779     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
    05780
    05788     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05789
    05797     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05798
    05808     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
    05809     {
    05810         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
    05811     }
    05812
    05825     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
    05826     {
    05827         return internalRequestProperty(QLatin1String("LocationAccessControl"));
    05828     }
    05829
    05842     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
    05843     {
    05844         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
    05845     }
    05846
    05860     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
    05861     {
    05862         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
    05863     }
    05864
    05871     Tp::PendingVariantMap *requestAllProperties() const
    05872     {
    05873         return internalRequestAllProperties();
    05874     }
    05875
    05876 public Q_SLOTS:
    05917     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
    05918     {
    05919         if (!invalidationReason().isEmpty()) {
    05920             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
    05921                 invalidationReason(),
    05922                 invalidationMessage()
    05923             ));
    05924         }
    05925
    05926         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05927                 this->staticInterfaceName(), QLatin1String("GetLocations"));
    05928         callMessage << QVariant::fromValue(contacts);
    05929         return this->connection().asyncCall(callMessage, timeout);
    05930     }
    05931
    05956     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
    05957     {
    05958         if (!invalidationReason().isEmpty()) {
    05959             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
    05960                 invalidationReason(),
    05961                 invalidationMessage()
    05962             ));
    05963         }
    05964
    05965         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05966                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
    05967         callMessage << QVariant::fromValue(contact);
    05968         return this->connection().asyncCall(callMessage, timeout);
    05969     }
    05970
    05992     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
    05993     {
    05994         if (!invalidationReason().isEmpty()) {
    05995             return QDBusPendingReply<>(QDBusMessage::createError(
    05996                 invalidationReason(),
    05997                 invalidationMessage()
    05998             ));
    05999         }
    06000
    06001         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06002                 this->staticInterfaceName(), QLatin1String("SetLocation"));
    06003         callMessage << QVariant::fromValue(location);
    06004         return this->connection().asyncCall(callMessage, timeout);
    06005     }
    06006
    06007 Q_SIGNALS:
    06022     void LocationUpdated(uint contact, const QVariantMap& location);
    06023
    06024 protected:
    06025     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06026 };
    06027
    06035 class TP_QT_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
    06036 {
    06037     Q_OBJECT
    06038
    06039 public:
    06046     static inline QLatin1String staticInterfaceName()
    06047     {
    06048         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
    06049     }
    06050
    06058     ConnectionInterfaceMailNotificationInterface(
    06059         const QString& busName,
    06060         const QString& objectPath,
    06061         QObject* parent = 0
    06062     );
    06063
    06072     ConnectionInterfaceMailNotificationInterface(
    06073         const QDBusConnection& connection,
    06074         const QString& busName,
    06075         const QString& objectPath,
    06076         QObject* parent = 0
    06077     );
    06078
    06085     ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
    06086
    06094     explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06095
    06103     ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06104
    06119     inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
    06120     {
    06121         return internalRequestProperty(QLatin1String("MailNotificationFlags"));
    06122     }
    06123
    06148     inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
    06149     {
    06150         return internalRequestProperty(QLatin1String("UnreadMailCount"));
    06151     }
    06152
    06169     inline Tp::PendingVariant *requestPropertyUnreadMails() const
    06170     {
    06171         return internalRequestProperty(QLatin1String("UnreadMails"));
    06172     }
    06173
    06188     inline Tp::PendingVariant *requestPropertyMailAddress() const
    06189     {
    06190         return internalRequestProperty(QLatin1String("MailAddress"));
    06191     }
    06192
    06199     Tp::PendingVariantMap *requestAllProperties() const
    06200     {
    06201         return internalRequestAllProperties();
    06202     }
    06203
    06204 public Q_SLOTS:
    06228     inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
    06229     {
    06230         if (!invalidationReason().isEmpty()) {
    06231             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
    06232                 invalidationReason(),
    06233                 invalidationMessage()
    06234             ));
    06235         }
    06236
    06237         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06238                 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
    06239         return this->connection().asyncCall(callMessage, timeout);
    06240     }
    06241
    06271     inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
    06272     {
    06273         if (!invalidationReason().isEmpty()) {
    06274             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
    06275                 invalidationReason(),
    06276                 invalidationMessage()
    06277             ));
    06278         }
    06279
    06280         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06281                 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
    06282         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
    06283         return this->connection().asyncCall(callMessage, timeout);
    06284     }
    06285
    06286 Q_SIGNALS:
    06309     void MailsReceived(const Tp::MailList& mails);
    06310
    06352     void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
    06353
    06354 protected:
    06355     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06356 };
    06357
    06365 class TP_QT_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
    06366 {
    06367     Q_OBJECT
    06368
    06369 public:
    06376     static inline QLatin1String staticInterfaceName()
    06377     {
    06378         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
    06379     }
    06380
    06388     ConnectionInterfacePowerSavingInterface(
    06389         const QString& busName,
    06390         const QString& objectPath,
    06391         QObject* parent = 0
    06392     );
    06393
    06402     ConnectionInterfacePowerSavingInterface(
    06403         const QDBusConnection& connection,
    06404         const QString& busName,
    06405         const QString& objectPath,
    06406         QObject* parent = 0
    06407     );
    06408
    06415     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
    06416
    06424     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06425
    06433     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06434
    06450     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
    06451     {
    06452         return internalRequestProperty(QLatin1String("PowerSavingActive"));
    06453     }
    06454
    06461     Tp::PendingVariantMap *requestAllProperties() const
    06462     {
    06463         return internalRequestAllProperties();
    06464     }
    06465
    06466 public Q_SLOTS:
    06500     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
    06501     {
    06502         if (!invalidationReason().isEmpty()) {
    06503             return QDBusPendingReply<>(QDBusMessage::createError(
    06504                 invalidationReason(),
    06505                 invalidationMessage()
    06506             ));
    06507         }
    06508
    06509         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06510                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
    06511         callMessage << QVariant::fromValue(activate);
    06512         return this->connection().asyncCall(callMessage, timeout);
    06513     }
    06514
    06515 Q_SIGNALS:
    06528     void PowerSavingChanged(bool active);
    06529
    06530 protected:
    06531     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06532 };
    06533
    06541 class TP_QT_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
    06542 {
    06543     Q_OBJECT
    06544
    06545 public:
    06552     static inline QLatin1String staticInterfaceName()
    06553     {
    06554         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
    06555     }
    06556
    06564     ConnectionInterfacePresenceInterface(
    06565         const QString& busName,
    06566         const QString& objectPath,
    06567         QObject* parent = 0
    06568     );
    06569
    06578     ConnectionInterfacePresenceInterface(
    06579         const QDBusConnection& connection,
    06580         const QString& busName,
    06581         const QString& objectPath,
    06582         QObject* parent = 0
    06583     );
    06584
    06591     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
    06592
    06600     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06601
    06609     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06610
    06617     Tp::PendingVariantMap *requestAllProperties() const
    06618     {
    06619         return internalRequestAllProperties();
    06620     }
    06621
    06622 public Q_SLOTS:
    06644     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
    06645     {
    06646         if (!invalidationReason().isEmpty()) {
    06647             return QDBusPendingReply<>(QDBusMessage::createError(
    06648                 invalidationReason(),
    06649                 invalidationMessage()
    06650             ));
    06651         }
    06652
    06653         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06654                 this->staticInterfaceName(), QLatin1String("AddStatus"));
    06655         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
    06656         return this->connection().asyncCall(callMessage, timeout);
    06657     }
    06658
    06672     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
    06673     {
    06674         if (!invalidationReason().isEmpty()) {
    06675             return QDBusPendingReply<>(QDBusMessage::createError(
    06676                 invalidationReason(),
    06677                 invalidationMessage()
    06678             ));
    06679         }
    06680
    06681         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06682                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
    06683         return this->connection().asyncCall(callMessage, timeout);
    06684     }
    06685
    06709     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
    06710     {
    06711         if (!invalidationReason().isEmpty()) {
    06712             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
    06713                 invalidationReason(),
    06714                 invalidationMessage()
    06715             ));
    06716         }
    06717
    06718         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06719                 this->staticInterfaceName(), QLatin1String("GetPresence"));
    06720         callMessage << QVariant::fromValue(contacts);
    06721         return this->connection().asyncCall(callMessage, timeout);
    06722     }
    06723
    06745     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
    06746     {
    06747         if (!invalidationReason().isEmpty()) {
    06748             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
    06749                 invalidationReason(),
    06750                 invalidationMessage()
    06751             ));
    06752         }
    06753
    06754         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06755                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
    06756         return this->connection().asyncCall(callMessage, timeout);
    06757     }
    06758
    06777     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
    06778     {
    06779         if (!invalidationReason().isEmpty()) {
    06780             return QDBusPendingReply<>(QDBusMessage::createError(
    06781                 invalidationReason(),
    06782                 invalidationMessage()
    06783             ));
    06784         }
    06785
    06786         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06787                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
    06788         callMessage << QVariant::fromValue(status);
    06789         return this->connection().asyncCall(callMessage, timeout);
    06790     }
    06791
    06810     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
    06811     {
    06812         if (!invalidationReason().isEmpty()) {
    06813             return QDBusPendingReply<>(QDBusMessage::createError(
    06814                 invalidationReason(),
    06815                 invalidationMessage()
    06816             ));
    06817         }
    06818
    06819         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06820                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
    06821         callMessage << QVariant::fromValue(contacts);
    06822         return this->connection().asyncCall(callMessage, timeout);
    06823     }
    06824
    06840     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
    06841     {
    06842         if (!invalidationReason().isEmpty()) {
    06843             return QDBusPendingReply<>(QDBusMessage::createError(
    06844                 invalidationReason(),
    06845                 invalidationMessage()
    06846             ));
    06847         }
    06848
    06849         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06850                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
    06851         callMessage << QVariant::fromValue(time);
    06852         return this->connection().asyncCall(callMessage, timeout);
    06853     }
    06854
    06892     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
    06893     {
    06894         if (!invalidationReason().isEmpty()) {
    06895             return QDBusPendingReply<>(QDBusMessage::createError(
    06896                 invalidationReason(),
    06897                 invalidationMessage()
    06898             ));
    06899         }
    06900
    06901         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06902                 this->staticInterfaceName(), QLatin1String("SetStatus"));
    06903         callMessage << QVariant::fromValue(statuses);
    06904         return this->connection().asyncCall(callMessage, timeout);
    06905     }
    06906
    06907 Q_SIGNALS:
    06924     void PresenceUpdate(const Tp::ContactPresences& presence);
    06925
    06926 protected:
    06927     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06928 };
    06929
    06937 class TP_QT_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
    06938 {
    06939     Q_OBJECT
    06940
    06941 public:
    06948     static inline QLatin1String staticInterfaceName()
    06949     {
    06950         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
    06951     }
    06952
    06960     ConnectionInterfaceRequestsInterface(
    06961         const QString& busName,
    06962         const QString& objectPath,
    06963         QObject* parent = 0
    06964     );
    06965
    06974     ConnectionInterfaceRequestsInterface(
    06975         const QDBusConnection& connection,
    06976         const QString& busName,
    06977         const QString& objectPath,
    06978         QObject* parent = 0
    06979     );
    06980
    06987     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
    06988
    06996     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06997
    07005     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07006
    07017     inline Tp::PendingVariant *requestPropertyChannels() const
    07018     {
    07019         return internalRequestProperty(QLatin1String("Channels"));
    07020     }
    07021
    07051     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
    07052     {
    07053         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
    07054     }
    07055
    07062     Tp::PendingVariantMap *requestAllProperties() const
    07063     {
    07064         return internalRequestAllProperties();
    07065     }
    07066
    07067 public Q_SLOTS:
    07149     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
    07150     {
    07151         if (!invalidationReason().isEmpty()) {
    07152             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    07153                 invalidationReason(),
    07154                 invalidationMessage()
    07155             ));
    07156         }
    07157
    07158         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07159                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
    07160         callMessage << QVariant::fromValue(request);
    07161         return this->connection().asyncCall(callMessage, timeout);
    07162     }
    07163
    07228     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
    07229     {
    07230         if (!invalidationReason().isEmpty()) {
    07231             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    07232                 invalidationReason(),
    07233                 invalidationMessage()
    07234             ));
    07235         }
    07236
    07237         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07238                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
    07239         callMessage << QVariant::fromValue(request);
    07240         return this->connection().asyncCall(callMessage, timeout);
    07241     }
    07242
    07243 Q_SIGNALS:
    07287     void NewChannels(const Tp::ChannelDetailsList& channels);
    07288
    07301     void ChannelClosed(const QDBusObjectPath& removed);
    07302
    07303 protected:
    07304     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07305 };
    07306
    07314 class TP_QT_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
    07315 {
    07316     Q_OBJECT
    07317
    07318 public:
    07325     static inline QLatin1String staticInterfaceName()
    07326     {
    07327         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
    07328     }
    07329
    07337     ConnectionInterfaceServicePointInterface(
    07338         const QString& busName,
    07339         const QString& objectPath,
    07340         QObject* parent = 0
    07341     );
    07342
    07351     ConnectionInterfaceServicePointInterface(
    07352         const QDBusConnection& connection,
    07353         const QString& busName,
    07354         const QString& objectPath,
    07355         QObject* parent = 0
    07356     );
    07357
    07364     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
    07365
    07373     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
    07374
    07382     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07383
    07395     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
    07396     {
    07397         return internalRequestProperty(QLatin1String("KnownServicePoints"));
    07398     }
    07399
    07406     Tp::PendingVariantMap *requestAllProperties() const
    07407     {
    07408         return internalRequestAllProperties();
    07409     }
    07410
    07411 Q_SIGNALS:
    07425     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
    07426
    07427 protected:
    07428     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07429 };
    07430
    07438 class TP_QT_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
    07439 {
    07440     Q_OBJECT
    07441
    07442 public:
    07449     static inline QLatin1String staticInterfaceName()
    07450     {
    07451         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
    07452     }
    07453
    07461     ConnectionInterfaceSimplePresenceInterface(
    07462         const QString& busName,
    07463         const QString& objectPath,
    07464         QObject* parent = 0
    07465     );
    07466
    07475     ConnectionInterfaceSimplePresenceInterface(
    07476         const QDBusConnection& connection,
    07477         const QString& busName,
    07478         const QString& objectPath,
    07479         QObject* parent = 0
    07480     );
    07481
    07488     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
    07489
    07497     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    07498
    07506     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07507
    07549     inline Tp::PendingVariant *requestPropertyStatuses() const
    07550     {
    07551         return internalRequestProperty(QLatin1String("Statuses"));
    07552     }
    07553
    07598     inline Tp::PendingVariant *requestPropertyMaximumStatusMessageLength() const
    07599     {
    07600         return internalRequestProperty(QLatin1String("MaximumStatusMessageLength"));
    07601     }
    07602
    07609     Tp::PendingVariantMap *requestAllProperties() const
    07610     {
    07611         return internalRequestAllProperties();
    07612     }
    07613
    07614 public Q_SLOTS:
    07678     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
    07679     {
    07680         if (!invalidationReason().isEmpty()) {
    07681             return QDBusPendingReply<>(QDBusMessage::createError(
    07682                 invalidationReason(),
    07683                 invalidationMessage()
    07684             ));
    07685         }
    07686
    07687         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07688                 this->staticInterfaceName(), QLatin1String("SetPresence"));
    07689         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
    07690         return this->connection().asyncCall(callMessage, timeout);
    07691     }
    07692
    07724     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
    07725     {
    07726         if (!invalidationReason().isEmpty()) {
    07727             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
    07728                 invalidationReason(),
    07729                 invalidationMessage()
    07730             ));
    07731         }
    07732
    07733         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07734                 this->staticInterfaceName(), QLatin1String("GetPresences"));
    07735         callMessage << QVariant::fromValue(contacts);
    07736         return this->connection().asyncCall(callMessage, timeout);
    07737     }
    07738
    07739 Q_SIGNALS:
    07752     void PresencesChanged(const Tp::SimpleContactPresences& presence);
    07753
    07754 protected:
    07755     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07756 };
    07757 }
    07758 }
    07759 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
    07760 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAddressingInterface*)
    07761 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
    07762 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
    07763 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
    07764 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
    07765 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
    07766 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
    07767 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
    07768 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
    07769 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
    07770 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
    07771 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
    07772 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
    07773 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
    07774 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
    07775 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
    07776 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
    07777 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
    07778 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
    07779 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
    07780 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)