| 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 ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
    01004 {
    01005     Q_OBJECT
    01006
    01007 public:
    01014     static inline QLatin1String staticInterfaceName()
    01015     {
    01016         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
    01017     }
    01018
    01026     ConnectionInterfaceAliasingInterface(
    01027         const QString& busName,
    01028         const QString& objectPath,
    01029         QObject* parent = 0
    01030     );
    01031
    01040     ConnectionInterfaceAliasingInterface(
    01041         const QDBusConnection& connection,
    01042         const QString& busName,
    01043         const QString& objectPath,
    01044         QObject* parent = 0
    01045     );
    01046
    01053     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
    01054
    01062     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01063
    01071     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01072
    01079     Tp::PendingVariantMap *requestAllProperties() const
    01080     {
    01081         return internalRequestAllProperties();
    01082     }
    01083
    01084 public Q_SLOTS:
    01100     inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
    01101     {
    01102         if (!invalidationReason().isEmpty()) {
    01103             return QDBusPendingReply<uint>(QDBusMessage::createError(
    01104                 invalidationReason(),
    01105                 invalidationMessage()
    01106             ));
    01107         }
    01108
    01109         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01110                 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
    01111         return this->connection().asyncCall(callMessage, timeout);
    01112     }
    01113
    01132     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
    01133     {
    01134         if (!invalidationReason().isEmpty()) {
    01135             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    01136                 invalidationReason(),
    01137                 invalidationMessage()
    01138             ));
    01139         }
    01140
    01141         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01142                 this->staticInterfaceName(), QLatin1String("RequestAliases"));
    01143         callMessage << QVariant::fromValue(contacts);
    01144         return this->connection().asyncCall(callMessage, timeout);
    01145     }
    01146
    01169     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
    01170     {
    01171         if (!invalidationReason().isEmpty()) {
    01172             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
    01173                 invalidationReason(),
    01174                 invalidationMessage()
    01175             ));
    01176         }
    01177
    01178         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01179                 this->staticInterfaceName(), QLatin1String("GetAliases"));
    01180         callMessage << QVariant::fromValue(contacts);
    01181         return this->connection().asyncCall(callMessage, timeout);
    01182     }
    01183
    01203     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
    01204     {
    01205         if (!invalidationReason().isEmpty()) {
    01206             return QDBusPendingReply<>(QDBusMessage::createError(
    01207                 invalidationReason(),
    01208                 invalidationMessage()
    01209             ));
    01210         }
    01211
    01212         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01213                 this->staticInterfaceName(), QLatin1String("SetAliases"));
    01214         callMessage << QVariant::fromValue(aliases);
    01215         return this->connection().asyncCall(callMessage, timeout);
    01216     }
    01217
    01218 Q_SIGNALS:
    01235     void AliasesChanged(const Tp::AliasPairList& aliases);
    01236
    01237 protected:
    01238     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01239 };
    01240
    01248 class TP_QT_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
    01249 {
    01250     Q_OBJECT
    01251
    01252 public:
    01259     static inline QLatin1String staticInterfaceName()
    01260     {
    01261         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
    01262     }
    01263
    01271     ConnectionInterfaceAnonymityInterface(
    01272         const QString& busName,
    01273         const QString& objectPath,
    01274         QObject* parent = 0
    01275     );
    01276
    01285     ConnectionInterfaceAnonymityInterface(
    01286         const QDBusConnection& connection,
    01287         const QString& busName,
    01288         const QString& objectPath,
    01289         QObject* parent = 0
    01290     );
    01291
    01298     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
    01299
    01307     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01308
    01316     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01317
    01328     inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
    01329     {
    01330         return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
    01331     }
    01332
    01348     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
    01349     {
    01350         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
    01351     }
    01352
    01368     inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
    01369     {
    01370         return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
    01371     }
    01372
    01385     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
    01386     {
    01387         return internalRequestProperty(QLatin1String("AnonymityModes"));
    01388     }
    01389
    01402     inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
    01403     {
    01404         return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
    01405     }
    01406
    01413     Tp::PendingVariantMap *requestAllProperties() const
    01414     {
    01415         return internalRequestAllProperties();
    01416     }
    01417
    01418 Q_SIGNALS:
    01428     void AnonymityModesChanged(uint modes);
    01429
    01430 protected:
    01431     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01432 };
    01433
    01441 class TP_QT_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
    01442 {
    01443     Q_OBJECT
    01444
    01445 public:
    01452     static inline QLatin1String staticInterfaceName()
    01453     {
    01454         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
    01455     }
    01456
    01464     ConnectionInterfaceAvatarsInterface(
    01465         const QString& busName,
    01466         const QString& objectPath,
    01467         QObject* parent = 0
    01468     );
    01469
    01478     ConnectionInterfaceAvatarsInterface(
    01479         const QDBusConnection& connection,
    01480         const QString& busName,
    01481         const QString& objectPath,
    01482         QObject* parent = 0
    01483     );
    01484
    01491     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
    01492
    01500     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01501
    01509     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01510
    01522     inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
    01523     {
    01524         return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
    01525     }
    01526
    01538     inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
    01539     {
    01540         return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
    01541     }
    01542
    01554     inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
    01555     {
    01556         return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
    01557     }
    01558
    01573     inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
    01574     {
    01575         return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
    01576     }
    01577
    01590     inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
    01591     {
    01592         return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
    01593     }
    01594
    01606     inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
    01607     {
    01608         return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
    01609     }
    01610
    01622     inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
    01623     {
    01624         return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
    01625     }
    01626
    01638     inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
    01639     {
    01640         return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
    01641     }
    01642
    01649     Tp::PendingVariantMap *requestAllProperties() const
    01650     {
    01651         return internalRequestAllProperties();
    01652     }
    01653
    01654 public Q_SLOTS:
    01689     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
    01690     {
    01691         if (!invalidationReason().isEmpty()) {
    01692             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
    01693                 invalidationReason(),
    01694                 invalidationMessage()
    01695             ));
    01696         }
    01697
    01698         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01699                 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
    01700         return this->connection().asyncCall(callMessage, timeout);
    01701     }
    01702
    01724     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
    01725     {
    01726         if (!invalidationReason().isEmpty()) {
    01727             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    01728                 invalidationReason(),
    01729                 invalidationMessage()
    01730             ));
    01731         }
    01732
    01733         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01734                 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
    01735         callMessage << QVariant::fromValue(contacts);
    01736         return this->connection().asyncCall(callMessage, timeout);
    01737     }
    01738
    01766     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
    01767     {
    01768         if (!invalidationReason().isEmpty()) {
    01769             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
    01770                 invalidationReason(),
    01771                 invalidationMessage()
    01772             ));
    01773         }
    01774
    01775         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01776                 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
    01777         callMessage << QVariant::fromValue(contacts);
    01778         return this->connection().asyncCall(callMessage, timeout);
    01779     }
    01780
    01805     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
    01806     {
    01807         if (!invalidationReason().isEmpty()) {
    01808             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
    01809                 invalidationReason(),
    01810                 invalidationMessage()
    01811             ));
    01812         }
    01813
    01814         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01815                 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
    01816         callMessage << QVariant::fromValue(contact);
    01817         return this->connection().asyncCall(callMessage, timeout);
    01818     }
    01819
    01838     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
    01839     {
    01840         if (!invalidationReason().isEmpty()) {
    01841             return QDBusPendingReply<>(QDBusMessage::createError(
    01842                 invalidationReason(),
    01843                 invalidationMessage()
    01844             ));
    01845         }
    01846
    01847         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01848                 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
    01849         callMessage << QVariant::fromValue(contacts);
    01850         return this->connection().asyncCall(callMessage, timeout);
    01851     }
    01852
    01876     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
    01877     {
    01878         if (!invalidationReason().isEmpty()) {
    01879             return QDBusPendingReply<QString>(QDBusMessage::createError(
    01880                 invalidationReason(),
    01881                 invalidationMessage()
    01882             ));
    01883         }
    01884
    01885         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01886                 this->staticInterfaceName(), QLatin1String("SetAvatar"));
    01887         callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
    01888         return this->connection().asyncCall(callMessage, timeout);
    01889     }
    01890
    01901     inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
    01902     {
    01903         if (!invalidationReason().isEmpty()) {
    01904             return QDBusPendingReply<>(QDBusMessage::createError(
    01905                 invalidationReason(),
    01906                 invalidationMessage()
    01907             ));
    01908         }
    01909
    01910         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    01911                 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
    01912         return this->connection().asyncCall(callMessage, timeout);
    01913     }
    01914
    01915 Q_SIGNALS:
    01932     void AvatarUpdated(uint contact, const QString& newAvatarToken);
    01933
    01956     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
    01957
    01958 protected:
    01959     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01960 };
    01961
    01969 class TP_QT_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
    01970 {
    01971     Q_OBJECT
    01972
    01973 public:
    01980     static inline QLatin1String staticInterfaceName()
    01981     {
    01982         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
    01983     }
    01984
    01992     ConnectionInterfaceBalanceInterface(
    01993         const QString& busName,
    01994         const QString& objectPath,
    01995         QObject* parent = 0
    01996     );
    01997
    02006     ConnectionInterfaceBalanceInterface(
    02007         const QDBusConnection& connection,
    02008         const QString& busName,
    02009         const QString& objectPath,
    02010         QObject* parent = 0
    02011     );
    02012
    02019     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
    02020
    02028     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02029
    02037     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02038
    02057     inline Tp::PendingVariant *requestPropertyAccountBalance() const
    02058     {
    02059         return internalRequestProperty(QLatin1String("AccountBalance"));
    02060     }
    02061
    02079     inline Tp::PendingVariant *requestPropertyManageCreditURI() const
    02080     {
    02081         return internalRequestProperty(QLatin1String("ManageCreditURI"));
    02082     }
    02083
    02090     Tp::PendingVariantMap *requestAllProperties() const
    02091     {
    02092         return internalRequestAllProperties();
    02093     }
    02094
    02095 Q_SIGNALS:
    02110     void BalanceChanged(const Tp::CurrencyAmount& balance);
    02111
    02112 protected:
    02113     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02114 };
    02115
    02123 class TP_QT_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
    02124 {
    02125     Q_OBJECT
    02126
    02127 public:
    02134     static inline QLatin1String staticInterfaceName()
    02135     {
    02136         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
    02137     }
    02138
    02146     ConnectionInterfaceCapabilitiesInterface(
    02147         const QString& busName,
    02148         const QString& objectPath,
    02149         QObject* parent = 0
    02150     );
    02151
    02160     ConnectionInterfaceCapabilitiesInterface(
    02161         const QDBusConnection& connection,
    02162         const QString& busName,
    02163         const QString& objectPath,
    02164         QObject* parent = 0
    02165     );
    02166
    02173     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
    02174
    02182     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02183
    02191     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02192
    02199     Tp::PendingVariantMap *requestAllProperties() const
    02200     {
    02201         return internalRequestAllProperties();
    02202     }
    02203
    02204 public Q_SLOTS:
    02258     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
    02259     {
    02260         if (!invalidationReason().isEmpty()) {
    02261             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
    02262                 invalidationReason(),
    02263                 invalidationMessage()
    02264             ));
    02265         }
    02266
    02267         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02268                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
    02269         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
    02270         return this->connection().asyncCall(callMessage, timeout);
    02271     }
    02272
    02307     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
    02308     {
    02309         if (!invalidationReason().isEmpty()) {
    02310             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
    02311                 invalidationReason(),
    02312                 invalidationMessage()
    02313             ));
    02314         }
    02315
    02316         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02317                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
    02318         callMessage << QVariant::fromValue(handles);
    02319         return this->connection().asyncCall(callMessage, timeout);
    02320     }
    02321
    02322 Q_SIGNALS:
    02349     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
    02350
    02351 protected:
    02352     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02353 };
    02354
    02362 class TP_QT_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
    02363 {
    02364     Q_OBJECT
    02365
    02366 public:
    02373     static inline QLatin1String staticInterfaceName()
    02374     {
    02375         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
    02376     }
    02377
    02385     ConnectionInterfaceCellularInterface(
    02386         const QString& busName,
    02387         const QString& objectPath,
    02388         QObject* parent = 0
    02389     );
    02390
    02399     ConnectionInterfaceCellularInterface(
    02400         const QDBusConnection& connection,
    02401         const QString& busName,
    02402         const QString& objectPath,
    02403         QObject* parent = 0
    02404     );
    02405
    02412     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
    02413
    02421     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02422
    02430     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02431
    02450     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
    02451     {
    02452         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
    02453     }
    02454
    02473     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
    02474     {
    02475         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
    02476     }
    02477
    02500     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
    02501     {
    02502         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
    02503     }
    02504
    02527     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
    02528     {
    02529         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
    02530     }
    02531
    02548     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
    02549     {
    02550         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
    02551     }
    02552
    02569     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
    02570     {
    02571         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
    02572     }
    02573
    02587     inline Tp::PendingVariant *requestPropertyIMSI() const
    02588     {
    02589         return internalRequestProperty(QLatin1String("IMSI"));
    02590     }
    02591
    02610     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
    02611     {
    02612         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
    02613     }
    02614
    02633     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
    02634     {
    02635         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
    02636     }
    02637
    02663     inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
    02664     {
    02665         return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
    02666     }
    02667
    02693     inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
    02694     {
    02695         return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
    02696     }
    02697
    02704     Tp::PendingVariantMap *requestAllProperties() const
    02705     {
    02706         return internalRequestAllProperties();
    02707     }
    02708
    02709 Q_SIGNALS:
    02725     void IMSIChanged(const QString& IMSI);
    02726
    02727 protected:
    02728     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02729 };
    02730
    02738 class TP_QT_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
    02739 {
    02740     Q_OBJECT
    02741
    02742 public:
    02749     static inline QLatin1String staticInterfaceName()
    02750     {
    02751         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
    02752     }
    02753
    02761     ConnectionInterfaceClientTypesInterface(
    02762         const QString& busName,
    02763         const QString& objectPath,
    02764         QObject* parent = 0
    02765     );
    02766
    02775     ConnectionInterfaceClientTypesInterface(
    02776         const QDBusConnection& connection,
    02777         const QString& busName,
    02778         const QString& objectPath,
    02779         QObject* parent = 0
    02780     );
    02781
    02788     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
    02789
    02797     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02798
    02806     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02807
    02814     Tp::PendingVariantMap *requestAllProperties() const
    02815     {
    02816         return internalRequestAllProperties();
    02817     }
    02818
    02819 public Q_SLOTS:
    02848     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
    02849     {
    02850         if (!invalidationReason().isEmpty()) {
    02851             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
    02852                 invalidationReason(),
    02853                 invalidationMessage()
    02854             ));
    02855         }
    02856
    02857         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02858                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
    02859         callMessage << QVariant::fromValue(contacts);
    02860         return this->connection().asyncCall(callMessage, timeout);
    02861     }
    02862
    02887     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
    02888     {
    02889         if (!invalidationReason().isEmpty()) {
    02890             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    02891                 invalidationReason(),
    02892                 invalidationMessage()
    02893             ));
    02894         }
    02895
    02896         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02897                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
    02898         callMessage << QVariant::fromValue(contact);
    02899         return this->connection().asyncCall(callMessage, timeout);
    02900     }
    02901
    02902 Q_SIGNALS:
    02917     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
    02918
    02919 protected:
    02920     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02921 };
    02922
    02930 class TP_QT_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
    02931 {
    02932     Q_OBJECT
    02933
    02934 public:
    02941     static inline QLatin1String staticInterfaceName()
    02942     {
    02943         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
    02944     }
    02945
    02953     ConnectionInterfaceContactBlockingInterface(
    02954         const QString& busName,
    02955         const QString& objectPath,
    02956         QObject* parent = 0
    02957     );
    02958
    02967     ConnectionInterfaceContactBlockingInterface(
    02968         const QDBusConnection& connection,
    02969         const QString& busName,
    02970         const QString& objectPath,
    02971         QObject* parent = 0
    02972     );
    02973
    02980     ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
    02981
    02989     explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02990
    02998     ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02999
    03016     inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
    03017     {
    03018         return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
    03019     }
    03020
    03027     Tp::PendingVariantMap *requestAllProperties() const
    03028     {
    03029         return internalRequestAllProperties();
    03030     }
    03031
    03032 public Q_SLOTS:
    03092     inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
    03093     {
    03094         if (!invalidationReason().isEmpty()) {
    03095             return QDBusPendingReply<>(QDBusMessage::createError(
    03096                 invalidationReason(),
    03097                 invalidationMessage()
    03098             ));
    03099         }
    03100
    03101         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03102                 this->staticInterfaceName(), QLatin1String("BlockContacts"));
    03103         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
    03104         return this->connection().asyncCall(callMessage, timeout);
    03105     }
    03106
    03125     inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
    03126     {
    03127         if (!invalidationReason().isEmpty()) {
    03128             return QDBusPendingReply<>(QDBusMessage::createError(
    03129                 invalidationReason(),
    03130                 invalidationMessage()
    03131             ));
    03132         }
    03133
    03134         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03135                 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
    03136         callMessage << QVariant::fromValue(contacts);
    03137         return this->connection().asyncCall(callMessage, timeout);
    03138     }
    03139
    03160     inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
    03161     {
    03162         if (!invalidationReason().isEmpty()) {
    03163             return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
    03164                 invalidationReason(),
    03165                 invalidationMessage()
    03166             ));
    03167         }
    03168
    03169         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03170                 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
    03171         return this->connection().asyncCall(callMessage, timeout);
    03172     }
    03173
    03174 Q_SIGNALS:
    03193     void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
    03194
    03195 protected:
    03196     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03197 };
    03198
    03206 class TP_QT_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
    03207 {
    03208     Q_OBJECT
    03209
    03210 public:
    03217     static inline QLatin1String staticInterfaceName()
    03218     {
    03219         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
    03220     }
    03221
    03229     ConnectionInterfaceContactCapabilitiesInterface(
    03230         const QString& busName,
    03231         const QString& objectPath,
    03232         QObject* parent = 0
    03233     );
    03234
    03243     ConnectionInterfaceContactCapabilitiesInterface(
    03244         const QDBusConnection& connection,
    03245         const QString& busName,
    03246         const QString& objectPath,
    03247         QObject* parent = 0
    03248     );
    03249
    03256     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
    03257
    03265     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03266
    03274     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03275
    03282     Tp::PendingVariantMap *requestAllProperties() const
    03283     {
    03284         return internalRequestAllProperties();
    03285     }
    03286
    03287 public Q_SLOTS:
    03350     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
    03351     {
    03352         if (!invalidationReason().isEmpty()) {
    03353             return QDBusPendingReply<>(QDBusMessage::createError(
    03354                 invalidationReason(),
    03355                 invalidationMessage()
    03356             ));
    03357         }
    03358
    03359         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03360                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
    03361         callMessage << QVariant::fromValue(handlerCapabilities);
    03362         return this->connection().asyncCall(callMessage, timeout);
    03363     }
    03364
    03400     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
    03401     {
    03402         if (!invalidationReason().isEmpty()) {
    03403             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
    03404                 invalidationReason(),
    03405                 invalidationMessage()
    03406             ));
    03407         }
    03408
    03409         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03410                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
    03411         callMessage << QVariant::fromValue(handles);
    03412         return this->connection().asyncCall(callMessage, timeout);
    03413     }
    03414
    03415 Q_SIGNALS:
    03436     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
    03437
    03438 protected:
    03439     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03440 };
    03441
    03449 class TP_QT_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
    03450 {
    03451     Q_OBJECT
    03452
    03453 public:
    03460     static inline QLatin1String staticInterfaceName()
    03461     {
    03462         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
    03463     }
    03464
    03472     ConnectionInterfaceContactGroupsInterface(
    03473         const QString& busName,
    03474         const QString& objectPath,
    03475         QObject* parent = 0
    03476     );
    03477
    03486     ConnectionInterfaceContactGroupsInterface(
    03487         const QDBusConnection& connection,
    03488         const QString& busName,
    03489         const QString& objectPath,
    03490         QObject* parent = 0
    03491     );
    03492
    03499     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
    03500
    03508     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03509
    03517     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03518
    03535     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
    03536     {
    03537         return internalRequestProperty(QLatin1String("DisjointGroups"));
    03538     }
    03539
    03552     inline Tp::PendingVariant *requestPropertyGroupStorage() const
    03553     {
    03554         return internalRequestProperty(QLatin1String("GroupStorage"));
    03555     }
    03556
    03580     inline Tp::PendingVariant *requestPropertyGroups() const
    03581     {
    03582         return internalRequestProperty(QLatin1String("Groups"));
    03583     }
    03584
    03591     Tp::PendingVariantMap *requestAllProperties() const
    03592     {
    03593         return internalRequestAllProperties();
    03594     }
    03595
    03596 public Q_SLOTS:
    03645     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
    03646     {
    03647         if (!invalidationReason().isEmpty()) {
    03648             return QDBusPendingReply<>(QDBusMessage::createError(
    03649                 invalidationReason(),
    03650                 invalidationMessage()
    03651             ));
    03652         }
    03653
    03654         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03655                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
    03656         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
    03657         return this->connection().asyncCall(callMessage, timeout);
    03658     }
    03659
    03707     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03708     {
    03709         if (!invalidationReason().isEmpty()) {
    03710             return QDBusPendingReply<>(QDBusMessage::createError(
    03711                 invalidationReason(),
    03712                 invalidationMessage()
    03713             ));
    03714         }
    03715
    03716         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03717                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
    03718         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    03719         return this->connection().asyncCall(callMessage, timeout);
    03720     }
    03721
    03762     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03763     {
    03764         if (!invalidationReason().isEmpty()) {
    03765             return QDBusPendingReply<>(QDBusMessage::createError(
    03766                 invalidationReason(),
    03767                 invalidationMessage()
    03768             ));
    03769         }
    03770
    03771         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03772                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
    03773         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    03774         return this->connection().asyncCall(callMessage, timeout);
    03775     }
    03776
    03816     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03817     {
    03818         if (!invalidationReason().isEmpty()) {
    03819             return QDBusPendingReply<>(QDBusMessage::createError(
    03820                 invalidationReason(),
    03821                 invalidationMessage()
    03822             ));
    03823         }
    03824
    03825         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03826                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
    03827         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    03828         return this->connection().asyncCall(callMessage, timeout);
    03829     }
    03830
    03859     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
    03860     {
    03861         if (!invalidationReason().isEmpty()) {
    03862             return QDBusPendingReply<>(QDBusMessage::createError(
    03863                 invalidationReason(),
    03864                 invalidationMessage()
    03865             ));
    03866         }
    03867
    03868         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03869                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
    03870         callMessage << QVariant::fromValue(group);
    03871         return this->connection().asyncCall(callMessage, timeout);
    03872     }
    03873
    03913     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
    03914     {
    03915         if (!invalidationReason().isEmpty()) {
    03916             return QDBusPendingReply<>(QDBusMessage::createError(
    03917                 invalidationReason(),
    03918                 invalidationMessage()
    03919             ));
    03920         }
    03921
    03922         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03923                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
    03924         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
    03925         return this->connection().asyncCall(callMessage, timeout);
    03926     }
    03927
    03928 Q_SIGNALS:
    03946     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
    03947
    03958     void GroupsCreated(const QStringList& names);
    03959
    04007     void GroupRenamed(const QString& oldName, const QString& newName);
    04008
    04035     void GroupsRemoved(const QStringList& names);
    04036
    04037 protected:
    04038     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04039 };
    04040
    04048 class TP_QT_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
    04049 {
    04050     Q_OBJECT
    04051
    04052 public:
    04059     static inline QLatin1String staticInterfaceName()
    04060     {
    04061         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
    04062     }
    04063
    04071     ConnectionInterfaceContactInfoInterface(
    04072         const QString& busName,
    04073         const QString& objectPath,
    04074         QObject* parent = 0
    04075     );
    04076
    04085     ConnectionInterfaceContactInfoInterface(
    04086         const QDBusConnection& connection,
    04087         const QString& busName,
    04088         const QString& objectPath,
    04089         QObject* parent = 0
    04090     );
    04091
    04098     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
    04099
    04107     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
    04108
    04116     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    04117
    04141     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
    04142     {
    04143         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
    04144     }
    04145
    04203     inline Tp::PendingVariant *requestPropertySupportedFields() const
    04204     {
    04205         return internalRequestProperty(QLatin1String("SupportedFields"));
    04206     }
    04207
    04214     Tp::PendingVariantMap *requestAllProperties() const
    04215     {
    04216         return internalRequestAllProperties();
    04217     }
    04218
    04219 public Q_SLOTS:
    04242     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    04243     {
    04244         if (!invalidationReason().isEmpty()) {
    04245             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
    04246                 invalidationReason(),
    04247                 invalidationMessage()
    04248             ));
    04249         }
    04250
    04251         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04252                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
    04253         callMessage << QVariant::fromValue(contacts);
    04254         return this->connection().asyncCall(callMessage, timeout);
    04255     }
    04256
    04276     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    04277     {
    04278         if (!invalidationReason().isEmpty()) {
    04279             return QDBusPendingReply<>(QDBusMessage::createError(
    04280                 invalidationReason(),
    04281                 invalidationMessage()
    04282             ));
    04283         }
    04284
    04285         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04286                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
    04287         callMessage << QVariant::fromValue(contacts);
    04288         return this->connection().asyncCall(callMessage, timeout);
    04289     }
    04290
    04312     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
    04313     {
    04314         if (!invalidationReason().isEmpty()) {
    04315             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
    04316                 invalidationReason(),
    04317                 invalidationMessage()
    04318             ));
    04319         }
    04320
    04321         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04322                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
    04323         callMessage << QVariant::fromValue(contact);
    04324         return this->connection().asyncCall(callMessage, timeout);
    04325     }
    04326
    04344     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
    04345     {
    04346         if (!invalidationReason().isEmpty()) {
    04347             return QDBusPendingReply<>(QDBusMessage::createError(
    04348                 invalidationReason(),
    04349                 invalidationMessage()
    04350             ));
    04351         }
    04352
    04353         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04354                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
    04355         callMessage << QVariant::fromValue(contactInfo);
    04356         return this->connection().asyncCall(callMessage, timeout);
    04357     }
    04358
    04359 Q_SIGNALS:
    04376     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
    04377
    04378 protected:
    04379     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04380 };
    04381
    04389 class TP_QT_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
    04390 {
    04391     Q_OBJECT
    04392
    04393 public:
    04400     static inline QLatin1String staticInterfaceName()
    04401     {
    04402         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
    04403     }
    04404
    04412     ConnectionInterfaceContactListInterface(
    04413         const QString& busName,
    04414         const QString& objectPath,
    04415         QObject* parent = 0
    04416     );
    04417
    04426     ConnectionInterfaceContactListInterface(
    04427         const QDBusConnection& connection,
    04428         const QString& busName,
    04429         const QString& objectPath,
    04430         QObject* parent = 0
    04431     );
    04432
    04439     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
    04440
    04448     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
    04449
    04457     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    04458
    04469     inline Tp::PendingVariant *requestPropertyContactListState() const
    04470     {
    04471         return internalRequestProperty(QLatin1String("ContactListState"));
    04472     }
    04473
    04533     inline Tp::PendingVariant *requestPropertyContactListPersists() const
    04534     {
    04535         return internalRequestProperty(QLatin1String("ContactListPersists"));
    04536     }
    04537
    04566     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
    04567     {
    04568         return internalRequestProperty(QLatin1String("CanChangeContactList"));
    04569     }
    04570
    04599     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
    04600     {
    04601         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
    04602     }
    04603
    04610     Tp::PendingVariantMap *requestAllProperties() const
    04611     {
    04612         return internalRequestAllProperties();
    04613     }
    04614
    04615 public Q_SLOTS:
    04687     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
    04688     {
    04689         if (!invalidationReason().isEmpty()) {
    04690             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    04691                 invalidationReason(),
    04692                 invalidationMessage()
    04693             ));
    04694         }
    04695
    04696         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04697                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
    04698         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    04699         return this->connection().asyncCall(callMessage, timeout);
    04700     }
    04701
    04812     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    04813     {
    04814         if (!invalidationReason().isEmpty()) {
    04815             return QDBusPendingReply<>(QDBusMessage::createError(
    04816                 invalidationReason(),
    04817                 invalidationMessage()
    04818             ));
    04819         }
    04820
    04821         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04822                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
    04823         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    04824         return this->connection().asyncCall(callMessage, timeout);
    04825     }
    04826
    04898     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
    04899     {
    04900         if (!invalidationReason().isEmpty()) {
    04901             return QDBusPendingReply<>(QDBusMessage::createError(
    04902                 invalidationReason(),
    04903                 invalidationMessage()
    04904             ));
    04905         }
    04906
    04907         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04908                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
    04909         callMessage << QVariant::fromValue(contacts);
    04910         return this->connection().asyncCall(callMessage, timeout);
    04911     }
    04912
    04962     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
    04963     {
    04964         if (!invalidationReason().isEmpty()) {
    04965             return QDBusPendingReply<>(QDBusMessage::createError(
    04966                 invalidationReason(),
    04967                 invalidationMessage()
    04968             ));
    04969         }
    04970
    04971         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04972                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
    04973         callMessage << QVariant::fromValue(contacts);
    04974         return this->connection().asyncCall(callMessage, timeout);
    04975     }
    04976
    05013     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
    05014     {
    05015         if (!invalidationReason().isEmpty()) {
    05016             return QDBusPendingReply<>(QDBusMessage::createError(
    05017                 invalidationReason(),
    05018                 invalidationMessage()
    05019             ));
    05020         }
    05021
    05022         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05023                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
    05024         callMessage << QVariant::fromValue(contacts);
    05025         return this->connection().asyncCall(callMessage, timeout);
    05026     }
    05027
    05064     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
    05065     {
    05066         if (!invalidationReason().isEmpty()) {
    05067             return QDBusPendingReply<>(QDBusMessage::createError(
    05068                 invalidationReason(),
    05069                 invalidationMessage()
    05070             ));
    05071         }
    05072
    05073         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05074                 this->staticInterfaceName(), QLatin1String("Unpublish"));
    05075         callMessage << QVariant::fromValue(contacts);
    05076         return this->connection().asyncCall(callMessage, timeout);
    05077     }
    05078
    05079 Q_SIGNALS:
    05089     void ContactListStateChanged(uint contactListState);
    05090
    05141     void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
    05142
    05165     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
    05166
    05167 protected:
    05168     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05169 };
    05170
    05178 class TP_QT_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
    05179 {
    05180     Q_OBJECT
    05181
    05182 public:
    05189     static inline QLatin1String staticInterfaceName()
    05190     {
    05191         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
    05192     }
    05193
    05201     ConnectionInterfaceContactsInterface(
    05202         const QString& busName,
    05203         const QString& objectPath,
    05204         QObject* parent = 0
    05205     );
    05206
    05215     ConnectionInterfaceContactsInterface(
    05216         const QDBusConnection& connection,
    05217         const QString& busName,
    05218         const QString& objectPath,
    05219         QObject* parent = 0
    05220     );
    05221
    05228     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
    05229
    05237     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05238
    05246     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05247
    05258     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
    05259     {
    05260         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
    05261     }
    05262
    05269     Tp::PendingVariantMap *requestAllProperties() const
    05270     {
    05271         return internalRequestAllProperties();
    05272     }
    05273
    05274 public Q_SLOTS:
    05357     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
    05358     {
    05359         if (!invalidationReason().isEmpty()) {
    05360             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    05361                 invalidationReason(),
    05362                 invalidationMessage()
    05363             ));
    05364         }
    05365
    05366         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05367                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
    05368         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    05369         return this->connection().asyncCall(callMessage, timeout);
    05370     }
    05371
    05372 protected:
    05373     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05374 };
    05375
    05383 class TP_QT_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
    05384 {
    05385     Q_OBJECT
    05386
    05387 public:
    05394     static inline QLatin1String staticInterfaceName()
    05395     {
    05396         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
    05397     }
    05398
    05406     ConnectionInterfaceLocationInterface(
    05407         const QString& busName,
    05408         const QString& objectPath,
    05409         QObject* parent = 0
    05410     );
    05411
    05420     ConnectionInterfaceLocationInterface(
    05421         const QDBusConnection& connection,
    05422         const QString& busName,
    05423         const QString& objectPath,
    05424         QObject* parent = 0
    05425     );
    05426
    05433     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
    05434
    05442     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05443
    05451     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05452
    05462     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
    05463     {
    05464         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
    05465     }
    05466
    05479     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
    05480     {
    05481         return internalRequestProperty(QLatin1String("LocationAccessControl"));
    05482     }
    05483
    05496     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
    05497     {
    05498         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
    05499     }
    05500
    05514     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
    05515     {
    05516         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
    05517     }
    05518
    05525     Tp::PendingVariantMap *requestAllProperties() const
    05526     {
    05527         return internalRequestAllProperties();
    05528     }
    05529
    05530 public Q_SLOTS:
    05571     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
    05572     {
    05573         if (!invalidationReason().isEmpty()) {
    05574             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
    05575                 invalidationReason(),
    05576                 invalidationMessage()
    05577             ));
    05578         }
    05579
    05580         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05581                 this->staticInterfaceName(), QLatin1String("GetLocations"));
    05582         callMessage << QVariant::fromValue(contacts);
    05583         return this->connection().asyncCall(callMessage, timeout);
    05584     }
    05585
    05610     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
    05611     {
    05612         if (!invalidationReason().isEmpty()) {
    05613             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
    05614                 invalidationReason(),
    05615                 invalidationMessage()
    05616             ));
    05617         }
    05618
    05619         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05620                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
    05621         callMessage << QVariant::fromValue(contact);
    05622         return this->connection().asyncCall(callMessage, timeout);
    05623     }
    05624
    05646     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
    05647     {
    05648         if (!invalidationReason().isEmpty()) {
    05649             return QDBusPendingReply<>(QDBusMessage::createError(
    05650                 invalidationReason(),
    05651                 invalidationMessage()
    05652             ));
    05653         }
    05654
    05655         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05656                 this->staticInterfaceName(), QLatin1String("SetLocation"));
    05657         callMessage << QVariant::fromValue(location);
    05658         return this->connection().asyncCall(callMessage, timeout);
    05659     }
    05660
    05661 Q_SIGNALS:
    05676     void LocationUpdated(uint contact, const QVariantMap& location);
    05677
    05678 protected:
    05679     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05680 };
    05681
    05689 class TP_QT_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
    05690 {
    05691     Q_OBJECT
    05692
    05693 public:
    05700     static inline QLatin1String staticInterfaceName()
    05701     {
    05702         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
    05703     }
    05704
    05712     ConnectionInterfaceMailNotificationInterface(
    05713         const QString& busName,
    05714         const QString& objectPath,
    05715         QObject* parent = 0
    05716     );
    05717
    05726     ConnectionInterfaceMailNotificationInterface(
    05727         const QDBusConnection& connection,
    05728         const QString& busName,
    05729         const QString& objectPath,
    05730         QObject* parent = 0
    05731     );
    05732
    05739     ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
    05740
    05748     explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05749
    05757     ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05758
    05773     inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
    05774     {
    05775         return internalRequestProperty(QLatin1String("MailNotificationFlags"));
    05776     }
    05777
    05802     inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
    05803     {
    05804         return internalRequestProperty(QLatin1String("UnreadMailCount"));
    05805     }
    05806
    05823     inline Tp::PendingVariant *requestPropertyUnreadMails() const
    05824     {
    05825         return internalRequestProperty(QLatin1String("UnreadMails"));
    05826     }
    05827
    05842     inline Tp::PendingVariant *requestPropertyMailAddress() const
    05843     {
    05844         return internalRequestProperty(QLatin1String("MailAddress"));
    05845     }
    05846
    05853     Tp::PendingVariantMap *requestAllProperties() const
    05854     {
    05855         return internalRequestAllProperties();
    05856     }
    05857
    05858 public Q_SLOTS:
    05882     inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
    05883     {
    05884         if (!invalidationReason().isEmpty()) {
    05885             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
    05886                 invalidationReason(),
    05887                 invalidationMessage()
    05888             ));
    05889         }
    05890
    05891         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05892                 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
    05893         return this->connection().asyncCall(callMessage, timeout);
    05894     }
    05895
    05925     inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
    05926     {
    05927         if (!invalidationReason().isEmpty()) {
    05928             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
    05929                 invalidationReason(),
    05930                 invalidationMessage()
    05931             ));
    05932         }
    05933
    05934         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05935                 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
    05936         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
    05937         return this->connection().asyncCall(callMessage, timeout);
    05938     }
    05939
    05940 Q_SIGNALS:
    05963     void MailsReceived(const Tp::MailList& mails);
    05964
    06006     void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
    06007
    06008 protected:
    06009     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06010 };
    06011
    06019 class TP_QT_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
    06020 {
    06021     Q_OBJECT
    06022
    06023 public:
    06030     static inline QLatin1String staticInterfaceName()
    06031     {
    06032         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
    06033     }
    06034
    06042     ConnectionInterfacePowerSavingInterface(
    06043         const QString& busName,
    06044         const QString& objectPath,
    06045         QObject* parent = 0
    06046     );
    06047
    06056     ConnectionInterfacePowerSavingInterface(
    06057         const QDBusConnection& connection,
    06058         const QString& busName,
    06059         const QString& objectPath,
    06060         QObject* parent = 0
    06061     );
    06062
    06069     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
    06070
    06078     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06079
    06087     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06088
    06104     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
    06105     {
    06106         return internalRequestProperty(QLatin1String("PowerSavingActive"));
    06107     }
    06108
    06115     Tp::PendingVariantMap *requestAllProperties() const
    06116     {
    06117         return internalRequestAllProperties();
    06118     }
    06119
    06120 public Q_SLOTS:
    06154     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
    06155     {
    06156         if (!invalidationReason().isEmpty()) {
    06157             return QDBusPendingReply<>(QDBusMessage::createError(
    06158                 invalidationReason(),
    06159                 invalidationMessage()
    06160             ));
    06161         }
    06162
    06163         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06164                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
    06165         callMessage << QVariant::fromValue(activate);
    06166         return this->connection().asyncCall(callMessage, timeout);
    06167     }
    06168
    06169 Q_SIGNALS:
    06182     void PowerSavingChanged(bool active);
    06183
    06184 protected:
    06185     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06186 };
    06187
    06195 class TP_QT_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
    06196 {
    06197     Q_OBJECT
    06198
    06199 public:
    06206     static inline QLatin1String staticInterfaceName()
    06207     {
    06208         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
    06209     }
    06210
    06218     ConnectionInterfacePresenceInterface(
    06219         const QString& busName,
    06220         const QString& objectPath,
    06221         QObject* parent = 0
    06222     );
    06223
    06232     ConnectionInterfacePresenceInterface(
    06233         const QDBusConnection& connection,
    06234         const QString& busName,
    06235         const QString& objectPath,
    06236         QObject* parent = 0
    06237     );
    06238
    06245     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
    06246
    06254     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06255
    06263     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06264
    06271     Tp::PendingVariantMap *requestAllProperties() const
    06272     {
    06273         return internalRequestAllProperties();
    06274     }
    06275
    06276 public Q_SLOTS:
    06298     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
    06299     {
    06300         if (!invalidationReason().isEmpty()) {
    06301             return QDBusPendingReply<>(QDBusMessage::createError(
    06302                 invalidationReason(),
    06303                 invalidationMessage()
    06304             ));
    06305         }
    06306
    06307         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06308                 this->staticInterfaceName(), QLatin1String("AddStatus"));
    06309         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
    06310         return this->connection().asyncCall(callMessage, timeout);
    06311     }
    06312
    06326     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
    06327     {
    06328         if (!invalidationReason().isEmpty()) {
    06329             return QDBusPendingReply<>(QDBusMessage::createError(
    06330                 invalidationReason(),
    06331                 invalidationMessage()
    06332             ));
    06333         }
    06334
    06335         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06336                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
    06337         return this->connection().asyncCall(callMessage, timeout);
    06338     }
    06339
    06363     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
    06364     {
    06365         if (!invalidationReason().isEmpty()) {
    06366             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
    06367                 invalidationReason(),
    06368                 invalidationMessage()
    06369             ));
    06370         }
    06371
    06372         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06373                 this->staticInterfaceName(), QLatin1String("GetPresence"));
    06374         callMessage << QVariant::fromValue(contacts);
    06375         return this->connection().asyncCall(callMessage, timeout);
    06376     }
    06377
    06399     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
    06400     {
    06401         if (!invalidationReason().isEmpty()) {
    06402             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
    06403                 invalidationReason(),
    06404                 invalidationMessage()
    06405             ));
    06406         }
    06407
    06408         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06409                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
    06410         return this->connection().asyncCall(callMessage, timeout);
    06411     }
    06412
    06431     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
    06432     {
    06433         if (!invalidationReason().isEmpty()) {
    06434             return QDBusPendingReply<>(QDBusMessage::createError(
    06435                 invalidationReason(),
    06436                 invalidationMessage()
    06437             ));
    06438         }
    06439
    06440         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06441                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
    06442         callMessage << QVariant::fromValue(status);
    06443         return this->connection().asyncCall(callMessage, timeout);
    06444     }
    06445
    06464     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
    06465     {
    06466         if (!invalidationReason().isEmpty()) {
    06467             return QDBusPendingReply<>(QDBusMessage::createError(
    06468                 invalidationReason(),
    06469                 invalidationMessage()
    06470             ));
    06471         }
    06472
    06473         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06474                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
    06475         callMessage << QVariant::fromValue(contacts);
    06476         return this->connection().asyncCall(callMessage, timeout);
    06477     }
    06478
    06494     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
    06495     {
    06496         if (!invalidationReason().isEmpty()) {
    06497             return QDBusPendingReply<>(QDBusMessage::createError(
    06498                 invalidationReason(),
    06499                 invalidationMessage()
    06500             ));
    06501         }
    06502
    06503         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06504                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
    06505         callMessage << QVariant::fromValue(time);
    06506         return this->connection().asyncCall(callMessage, timeout);
    06507     }
    06508
    06546     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
    06547     {
    06548         if (!invalidationReason().isEmpty()) {
    06549             return QDBusPendingReply<>(QDBusMessage::createError(
    06550                 invalidationReason(),
    06551                 invalidationMessage()
    06552             ));
    06553         }
    06554
    06555         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06556                 this->staticInterfaceName(), QLatin1String("SetStatus"));
    06557         callMessage << QVariant::fromValue(statuses);
    06558         return this->connection().asyncCall(callMessage, timeout);
    06559     }
    06560
    06561 Q_SIGNALS:
    06578     void PresenceUpdate(const Tp::ContactPresences& presence);
    06579
    06580 protected:
    06581     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06582 };
    06583
    06591 class TP_QT_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
    06592 {
    06593     Q_OBJECT
    06594
    06595 public:
    06602     static inline QLatin1String staticInterfaceName()
    06603     {
    06604         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
    06605     }
    06606
    06614     ConnectionInterfaceRequestsInterface(
    06615         const QString& busName,
    06616         const QString& objectPath,
    06617         QObject* parent = 0
    06618     );
    06619
    06628     ConnectionInterfaceRequestsInterface(
    06629         const QDBusConnection& connection,
    06630         const QString& busName,
    06631         const QString& objectPath,
    06632         QObject* parent = 0
    06633     );
    06634
    06641     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
    06642
    06650     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06651
    06659     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06660
    06671     inline Tp::PendingVariant *requestPropertyChannels() const
    06672     {
    06673         return internalRequestProperty(QLatin1String("Channels"));
    06674     }
    06675
    06705     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
    06706     {
    06707         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
    06708     }
    06709
    06716     Tp::PendingVariantMap *requestAllProperties() const
    06717     {
    06718         return internalRequestAllProperties();
    06719     }
    06720
    06721 public Q_SLOTS:
    06803     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
    06804     {
    06805         if (!invalidationReason().isEmpty()) {
    06806             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    06807                 invalidationReason(),
    06808                 invalidationMessage()
    06809             ));
    06810         }
    06811
    06812         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06813                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
    06814         callMessage << QVariant::fromValue(request);
    06815         return this->connection().asyncCall(callMessage, timeout);
    06816     }
    06817
    06882     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
    06883     {
    06884         if (!invalidationReason().isEmpty()) {
    06885             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    06886                 invalidationReason(),
    06887                 invalidationMessage()
    06888             ));
    06889         }
    06890
    06891         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06892                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
    06893         callMessage << QVariant::fromValue(request);
    06894         return this->connection().asyncCall(callMessage, timeout);
    06895     }
    06896
    06897 Q_SIGNALS:
    06941     void NewChannels(const Tp::ChannelDetailsList& channels);
    06942
    06955     void ChannelClosed(const QDBusObjectPath& removed);
    06956
    06957 protected:
    06958     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06959 };
    06960
    06968 class TP_QT_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
    06969 {
    06970     Q_OBJECT
    06971
    06972 public:
    06979     static inline QLatin1String staticInterfaceName()
    06980     {
    06981         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
    06982     }
    06983
    06991     ConnectionInterfaceServicePointInterface(
    06992         const QString& busName,
    06993         const QString& objectPath,
    06994         QObject* parent = 0
    06995     );
    06996
    07005     ConnectionInterfaceServicePointInterface(
    07006         const QDBusConnection& connection,
    07007         const QString& busName,
    07008         const QString& objectPath,
    07009         QObject* parent = 0
    07010     );
    07011
    07018     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
    07019
    07027     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
    07028
    07036     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07037
    07049     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
    07050     {
    07051         return internalRequestProperty(QLatin1String("KnownServicePoints"));
    07052     }
    07053
    07060     Tp::PendingVariantMap *requestAllProperties() const
    07061     {
    07062         return internalRequestAllProperties();
    07063     }
    07064
    07065 Q_SIGNALS:
    07079     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
    07080
    07081 protected:
    07082     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07083 };
    07084
    07092 class TP_QT_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
    07093 {
    07094     Q_OBJECT
    07095
    07096 public:
    07103     static inline QLatin1String staticInterfaceName()
    07104     {
    07105         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
    07106     }
    07107
    07115     ConnectionInterfaceSimplePresenceInterface(
    07116         const QString& busName,
    07117         const QString& objectPath,
    07118         QObject* parent = 0
    07119     );
    07120
    07129     ConnectionInterfaceSimplePresenceInterface(
    07130         const QDBusConnection& connection,
    07131         const QString& busName,
    07132         const QString& objectPath,
    07133         QObject* parent = 0
    07134     );
    07135
    07142     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
    07143
    07151     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    07152
    07160     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07161
    07203     inline Tp::PendingVariant *requestPropertyStatuses() const
    07204     {
    07205         return internalRequestProperty(QLatin1String("Statuses"));
    07206     }
    07207
    07252     inline Tp::PendingVariant *requestPropertyMaximumStatusMessageLength() const
    07253     {
    07254         return internalRequestProperty(QLatin1String("MaximumStatusMessageLength"));
    07255     }
    07256
    07263     Tp::PendingVariantMap *requestAllProperties() const
    07264     {
    07265         return internalRequestAllProperties();
    07266     }
    07267
    07268 public Q_SLOTS:
    07332     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
    07333     {
    07334         if (!invalidationReason().isEmpty()) {
    07335             return QDBusPendingReply<>(QDBusMessage::createError(
    07336                 invalidationReason(),
    07337                 invalidationMessage()
    07338             ));
    07339         }
    07340
    07341         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07342                 this->staticInterfaceName(), QLatin1String("SetPresence"));
    07343         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
    07344         return this->connection().asyncCall(callMessage, timeout);
    07345     }
    07346
    07378     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
    07379     {
    07380         if (!invalidationReason().isEmpty()) {
    07381             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
    07382                 invalidationReason(),
    07383                 invalidationMessage()
    07384             ));
    07385         }
    07386
    07387         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07388                 this->staticInterfaceName(), QLatin1String("GetPresences"));
    07389         callMessage << QVariant::fromValue(contacts);
    07390         return this->connection().asyncCall(callMessage, timeout);
    07391     }
    07392
    07393 Q_SIGNALS:
    07406     void PresencesChanged(const Tp::SimpleContactPresences& presence);
    07407
    07408 protected:
    07409     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07410 };
    07411 }
    07412 }
    07413 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
    07414 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
    07415 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
    07416 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
    07417 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
    07418 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
    07419 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
    07420 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
    07421 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
    07422 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
    07423 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
    07424 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
    07425 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
    07426 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
    07427 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
    07428 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
    07429 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
    07430 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
    07431 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
    07432 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
    07433 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)