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

cli-connection.h

    00001 /*
    00002  * This file contains D-Bus client proxy classes generated by qt4-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_TELEPATHY_QT4_HEADER
    00009 #error IN_TELEPATHY_QT4_HEADER
    00010 #endif
    00011
    00012 #include <TelepathyQt4/Types>
    00013
    00014 #include <QtGlobal>
    00015
    00016 #include <QString>
    00017 #include <QObject>
    00018 #include <QVariant>
    00019
    00020 #include <QDBusPendingReply>
    00021
    00022 #include <TelepathyQt4/AbstractInterface>
    00023 #include <TelepathyQt4/DBusProxy>
    00024 #include <TelepathyQt4/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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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 TELEPATHY_QT4_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
    02068     Tp::PendingVariantMap *requestAllProperties() const
    02069     {
    02070         return internalRequestAllProperties();
    02071     }
    02072
    02073 Q_SIGNALS:
    02088     void BalanceChanged(const Tp::CurrencyAmount& balance);
    02089
    02090 protected:
    02091     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02092 };
    02093
    02101 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
    02102 {
    02103     Q_OBJECT
    02104
    02105 public:
    02112     static inline QLatin1String staticInterfaceName()
    02113     {
    02114         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
    02115     }
    02116
    02124     ConnectionInterfaceCapabilitiesInterface(
    02125         const QString& busName,
    02126         const QString& objectPath,
    02127         QObject* parent = 0
    02128     );
    02129
    02138     ConnectionInterfaceCapabilitiesInterface(
    02139         const QDBusConnection& connection,
    02140         const QString& busName,
    02141         const QString& objectPath,
    02142         QObject* parent = 0
    02143     );
    02144
    02151     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
    02152
    02160     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02161
    02169     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02170
    02177     Tp::PendingVariantMap *requestAllProperties() const
    02178     {
    02179         return internalRequestAllProperties();
    02180     }
    02181
    02182 public Q_SLOTS:
    02236     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
    02237     {
    02238         if (!invalidationReason().isEmpty()) {
    02239             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
    02240                 invalidationReason(),
    02241                 invalidationMessage()
    02242             ));
    02243         }
    02244
    02245         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02246                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
    02247         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
    02248         return this->connection().asyncCall(callMessage, timeout);
    02249     }
    02250
    02285     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
    02286     {
    02287         if (!invalidationReason().isEmpty()) {
    02288             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
    02289                 invalidationReason(),
    02290                 invalidationMessage()
    02291             ));
    02292         }
    02293
    02294         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02295                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
    02296         callMessage << QVariant::fromValue(handles);
    02297         return this->connection().asyncCall(callMessage, timeout);
    02298     }
    02299
    02300 Q_SIGNALS:
    02327     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
    02328
    02329 protected:
    02330     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02331 };
    02332
    02340 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
    02341 {
    02342     Q_OBJECT
    02343
    02344 public:
    02351     static inline QLatin1String staticInterfaceName()
    02352     {
    02353         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
    02354     }
    02355
    02363     ConnectionInterfaceCellularInterface(
    02364         const QString& busName,
    02365         const QString& objectPath,
    02366         QObject* parent = 0
    02367     );
    02368
    02377     ConnectionInterfaceCellularInterface(
    02378         const QDBusConnection& connection,
    02379         const QString& busName,
    02380         const QString& objectPath,
    02381         QObject* parent = 0
    02382     );
    02383
    02390     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
    02391
    02399     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02400
    02408     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02409
    02428     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
    02429     {
    02430         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
    02431     }
    02432
    02451     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
    02452     {
    02453         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
    02454     }
    02455
    02478     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
    02479     {
    02480         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
    02481     }
    02482
    02505     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
    02506     {
    02507         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
    02508     }
    02509
    02526     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
    02527     {
    02528         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
    02529     }
    02530
    02547     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
    02548     {
    02549         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
    02550     }
    02551
    02565     inline Tp::PendingVariant *requestPropertyIMSI() const
    02566     {
    02567         return internalRequestProperty(QLatin1String("IMSI"));
    02568     }
    02569
    02588     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
    02589     {
    02590         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
    02591     }
    02592
    02611     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
    02612     {
    02613         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
    02614     }
    02615
    02641     inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
    02642     {
    02643         return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
    02644     }
    02645
    02671     inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
    02672     {
    02673         return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
    02674     }
    02675
    02682     Tp::PendingVariantMap *requestAllProperties() const
    02683     {
    02684         return internalRequestAllProperties();
    02685     }
    02686
    02687 Q_SIGNALS:
    02703     void IMSIChanged(const QString& IMSI);
    02704
    02705 protected:
    02706     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02707 };
    02708
    02716 class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
    02717 {
    02718     Q_OBJECT
    02719
    02720 public:
    02727     static inline QLatin1String staticInterfaceName()
    02728     {
    02729         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
    02730     }
    02731
    02739     ConnectionInterfaceClientTypesInterface(
    02740         const QString& busName,
    02741         const QString& objectPath,
    02742         QObject* parent = 0
    02743     );
    02744
    02753     ConnectionInterfaceClientTypesInterface(
    02754         const QDBusConnection& connection,
    02755         const QString& busName,
    02756         const QString& objectPath,
    02757         QObject* parent = 0
    02758     );
    02759
    02766     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
    02767
    02775     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02776
    02784     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02785
    02792     Tp::PendingVariantMap *requestAllProperties() const
    02793     {
    02794         return internalRequestAllProperties();
    02795     }
    02796
    02797 public Q_SLOTS:
    02826     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
    02827     {
    02828         if (!invalidationReason().isEmpty()) {
    02829             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
    02830                 invalidationReason(),
    02831                 invalidationMessage()
    02832             ));
    02833         }
    02834
    02835         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02836                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
    02837         callMessage << QVariant::fromValue(contacts);
    02838         return this->connection().asyncCall(callMessage, timeout);
    02839     }
    02840
    02865     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
    02866     {
    02867         if (!invalidationReason().isEmpty()) {
    02868             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    02869                 invalidationReason(),
    02870                 invalidationMessage()
    02871             ));
    02872         }
    02873
    02874         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    02875                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
    02876         callMessage << QVariant::fromValue(contact);
    02877         return this->connection().asyncCall(callMessage, timeout);
    02878     }
    02879
    02880 Q_SIGNALS:
    02895     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
    02896
    02897 protected:
    02898     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02899 };
    02900
    02908 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
    02909 {
    02910     Q_OBJECT
    02911
    02912 public:
    02919     static inline QLatin1String staticInterfaceName()
    02920     {
    02921         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
    02922     }
    02923
    02931     ConnectionInterfaceContactBlockingInterface(
    02932         const QString& busName,
    02933         const QString& objectPath,
    02934         QObject* parent = 0
    02935     );
    02936
    02945     ConnectionInterfaceContactBlockingInterface(
    02946         const QDBusConnection& connection,
    02947         const QString& busName,
    02948         const QString& objectPath,
    02949         QObject* parent = 0
    02950     );
    02951
    02958     ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
    02959
    02967     explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02968
    02976     ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02977
    02994     inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
    02995     {
    02996         return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
    02997     }
    02998
    03005     Tp::PendingVariantMap *requestAllProperties() const
    03006     {
    03007         return internalRequestAllProperties();
    03008     }
    03009
    03010 public Q_SLOTS:
    03070     inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
    03071     {
    03072         if (!invalidationReason().isEmpty()) {
    03073             return QDBusPendingReply<>(QDBusMessage::createError(
    03074                 invalidationReason(),
    03075                 invalidationMessage()
    03076             ));
    03077         }
    03078
    03079         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03080                 this->staticInterfaceName(), QLatin1String("BlockContacts"));
    03081         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
    03082         return this->connection().asyncCall(callMessage, timeout);
    03083     }
    03084
    03103     inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
    03104     {
    03105         if (!invalidationReason().isEmpty()) {
    03106             return QDBusPendingReply<>(QDBusMessage::createError(
    03107                 invalidationReason(),
    03108                 invalidationMessage()
    03109             ));
    03110         }
    03111
    03112         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03113                 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
    03114         callMessage << QVariant::fromValue(contacts);
    03115         return this->connection().asyncCall(callMessage, timeout);
    03116     }
    03117
    03138     inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
    03139     {
    03140         if (!invalidationReason().isEmpty()) {
    03141             return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
    03142                 invalidationReason(),
    03143                 invalidationMessage()
    03144             ));
    03145         }
    03146
    03147         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03148                 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
    03149         return this->connection().asyncCall(callMessage, timeout);
    03150     }
    03151
    03152 Q_SIGNALS:
    03171     void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
    03172
    03173 protected:
    03174     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03175 };
    03176
    03184 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
    03185 {
    03186     Q_OBJECT
    03187
    03188 public:
    03195     static inline QLatin1String staticInterfaceName()
    03196     {
    03197         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
    03198     }
    03199
    03207     ConnectionInterfaceContactCapabilitiesInterface(
    03208         const QString& busName,
    03209         const QString& objectPath,
    03210         QObject* parent = 0
    03211     );
    03212
    03221     ConnectionInterfaceContactCapabilitiesInterface(
    03222         const QDBusConnection& connection,
    03223         const QString& busName,
    03224         const QString& objectPath,
    03225         QObject* parent = 0
    03226     );
    03227
    03234     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
    03235
    03243     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03244
    03252     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03253
    03260     Tp::PendingVariantMap *requestAllProperties() const
    03261     {
    03262         return internalRequestAllProperties();
    03263     }
    03264
    03265 public Q_SLOTS:
    03328     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
    03329     {
    03330         if (!invalidationReason().isEmpty()) {
    03331             return QDBusPendingReply<>(QDBusMessage::createError(
    03332                 invalidationReason(),
    03333                 invalidationMessage()
    03334             ));
    03335         }
    03336
    03337         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03338                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
    03339         callMessage << QVariant::fromValue(handlerCapabilities);
    03340         return this->connection().asyncCall(callMessage, timeout);
    03341     }
    03342
    03378     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
    03379     {
    03380         if (!invalidationReason().isEmpty()) {
    03381             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
    03382                 invalidationReason(),
    03383                 invalidationMessage()
    03384             ));
    03385         }
    03386
    03387         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03388                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
    03389         callMessage << QVariant::fromValue(handles);
    03390         return this->connection().asyncCall(callMessage, timeout);
    03391     }
    03392
    03393 Q_SIGNALS:
    03414     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
    03415
    03416 protected:
    03417     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03418 };
    03419
    03427 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
    03428 {
    03429     Q_OBJECT
    03430
    03431 public:
    03438     static inline QLatin1String staticInterfaceName()
    03439     {
    03440         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
    03441     }
    03442
    03450     ConnectionInterfaceContactGroupsInterface(
    03451         const QString& busName,
    03452         const QString& objectPath,
    03453         QObject* parent = 0
    03454     );
    03455
    03464     ConnectionInterfaceContactGroupsInterface(
    03465         const QDBusConnection& connection,
    03466         const QString& busName,
    03467         const QString& objectPath,
    03468         QObject* parent = 0
    03469     );
    03470
    03477     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
    03478
    03486     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03487
    03495     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03496
    03513     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
    03514     {
    03515         return internalRequestProperty(QLatin1String("DisjointGroups"));
    03516     }
    03517
    03530     inline Tp::PendingVariant *requestPropertyGroupStorage() const
    03531     {
    03532         return internalRequestProperty(QLatin1String("GroupStorage"));
    03533     }
    03534
    03558     inline Tp::PendingVariant *requestPropertyGroups() const
    03559     {
    03560         return internalRequestProperty(QLatin1String("Groups"));
    03561     }
    03562
    03569     Tp::PendingVariantMap *requestAllProperties() const
    03570     {
    03571         return internalRequestAllProperties();
    03572     }
    03573
    03574 public Q_SLOTS:
    03623     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
    03624     {
    03625         if (!invalidationReason().isEmpty()) {
    03626             return QDBusPendingReply<>(QDBusMessage::createError(
    03627                 invalidationReason(),
    03628                 invalidationMessage()
    03629             ));
    03630         }
    03631
    03632         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03633                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
    03634         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
    03635         return this->connection().asyncCall(callMessage, timeout);
    03636     }
    03637
    03685     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03686     {
    03687         if (!invalidationReason().isEmpty()) {
    03688             return QDBusPendingReply<>(QDBusMessage::createError(
    03689                 invalidationReason(),
    03690                 invalidationMessage()
    03691             ));
    03692         }
    03693
    03694         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03695                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
    03696         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    03697         return this->connection().asyncCall(callMessage, timeout);
    03698     }
    03699
    03740     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03741     {
    03742         if (!invalidationReason().isEmpty()) {
    03743             return QDBusPendingReply<>(QDBusMessage::createError(
    03744                 invalidationReason(),
    03745                 invalidationMessage()
    03746             ));
    03747         }
    03748
    03749         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03750                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
    03751         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    03752         return this->connection().asyncCall(callMessage, timeout);
    03753     }
    03754
    03794     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
    03795     {
    03796         if (!invalidationReason().isEmpty()) {
    03797             return QDBusPendingReply<>(QDBusMessage::createError(
    03798                 invalidationReason(),
    03799                 invalidationMessage()
    03800             ));
    03801         }
    03802
    03803         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03804                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
    03805         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
    03806         return this->connection().asyncCall(callMessage, timeout);
    03807     }
    03808
    03837     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
    03838     {
    03839         if (!invalidationReason().isEmpty()) {
    03840             return QDBusPendingReply<>(QDBusMessage::createError(
    03841                 invalidationReason(),
    03842                 invalidationMessage()
    03843             ));
    03844         }
    03845
    03846         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03847                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
    03848         callMessage << QVariant::fromValue(group);
    03849         return this->connection().asyncCall(callMessage, timeout);
    03850     }
    03851
    03891     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
    03892     {
    03893         if (!invalidationReason().isEmpty()) {
    03894             return QDBusPendingReply<>(QDBusMessage::createError(
    03895                 invalidationReason(),
    03896                 invalidationMessage()
    03897             ));
    03898         }
    03899
    03900         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    03901                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
    03902         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
    03903         return this->connection().asyncCall(callMessage, timeout);
    03904     }
    03905
    03906 Q_SIGNALS:
    03924     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
    03925
    03936     void GroupsCreated(const QStringList& names);
    03937
    03985     void GroupRenamed(const QString& oldName, const QString& newName);
    03986
    04013     void GroupsRemoved(const QStringList& names);
    04014
    04015 protected:
    04016     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04017 };
    04018
    04026 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
    04027 {
    04028     Q_OBJECT
    04029
    04030 public:
    04037     static inline QLatin1String staticInterfaceName()
    04038     {
    04039         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
    04040     }
    04041
    04049     ConnectionInterfaceContactInfoInterface(
    04050         const QString& busName,
    04051         const QString& objectPath,
    04052         QObject* parent = 0
    04053     );
    04054
    04063     ConnectionInterfaceContactInfoInterface(
    04064         const QDBusConnection& connection,
    04065         const QString& busName,
    04066         const QString& objectPath,
    04067         QObject* parent = 0
    04068     );
    04069
    04076     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
    04077
    04085     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
    04086
    04094     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    04095
    04119     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
    04120     {
    04121         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
    04122     }
    04123
    04181     inline Tp::PendingVariant *requestPropertySupportedFields() const
    04182     {
    04183         return internalRequestProperty(QLatin1String("SupportedFields"));
    04184     }
    04185
    04192     Tp::PendingVariantMap *requestAllProperties() const
    04193     {
    04194         return internalRequestAllProperties();
    04195     }
    04196
    04197 public Q_SLOTS:
    04220     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    04221     {
    04222         if (!invalidationReason().isEmpty()) {
    04223             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
    04224                 invalidationReason(),
    04225                 invalidationMessage()
    04226             ));
    04227         }
    04228
    04229         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04230                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
    04231         callMessage << QVariant::fromValue(contacts);
    04232         return this->connection().asyncCall(callMessage, timeout);
    04233     }
    04234
    04254     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
    04255     {
    04256         if (!invalidationReason().isEmpty()) {
    04257             return QDBusPendingReply<>(QDBusMessage::createError(
    04258                 invalidationReason(),
    04259                 invalidationMessage()
    04260             ));
    04261         }
    04262
    04263         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04264                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
    04265         callMessage << QVariant::fromValue(contacts);
    04266         return this->connection().asyncCall(callMessage, timeout);
    04267     }
    04268
    04290     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
    04291     {
    04292         if (!invalidationReason().isEmpty()) {
    04293             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
    04294                 invalidationReason(),
    04295                 invalidationMessage()
    04296             ));
    04297         }
    04298
    04299         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04300                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
    04301         callMessage << QVariant::fromValue(contact);
    04302         return this->connection().asyncCall(callMessage, timeout);
    04303     }
    04304
    04322     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
    04323     {
    04324         if (!invalidationReason().isEmpty()) {
    04325             return QDBusPendingReply<>(QDBusMessage::createError(
    04326                 invalidationReason(),
    04327                 invalidationMessage()
    04328             ));
    04329         }
    04330
    04331         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04332                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
    04333         callMessage << QVariant::fromValue(contactInfo);
    04334         return this->connection().asyncCall(callMessage, timeout);
    04335     }
    04336
    04337 Q_SIGNALS:
    04354     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
    04355
    04356 protected:
    04357     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04358 };
    04359
    04367 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
    04368 {
    04369     Q_OBJECT
    04370
    04371 public:
    04378     static inline QLatin1String staticInterfaceName()
    04379     {
    04380         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
    04381     }
    04382
    04390     ConnectionInterfaceContactListInterface(
    04391         const QString& busName,
    04392         const QString& objectPath,
    04393         QObject* parent = 0
    04394     );
    04395
    04404     ConnectionInterfaceContactListInterface(
    04405         const QDBusConnection& connection,
    04406         const QString& busName,
    04407         const QString& objectPath,
    04408         QObject* parent = 0
    04409     );
    04410
    04417     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
    04418
    04426     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
    04427
    04435     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    04436
    04447     inline Tp::PendingVariant *requestPropertyContactListState() const
    04448     {
    04449         return internalRequestProperty(QLatin1String("ContactListState"));
    04450     }
    04451
    04511     inline Tp::PendingVariant *requestPropertyContactListPersists() const
    04512     {
    04513         return internalRequestProperty(QLatin1String("ContactListPersists"));
    04514     }
    04515
    04544     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
    04545     {
    04546         return internalRequestProperty(QLatin1String("CanChangeContactList"));
    04547     }
    04548
    04577     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
    04578     {
    04579         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
    04580     }
    04581
    04588     Tp::PendingVariantMap *requestAllProperties() const
    04589     {
    04590         return internalRequestAllProperties();
    04591     }
    04592
    04593 public Q_SLOTS:
    04665     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
    04666     {
    04667         if (!invalidationReason().isEmpty()) {
    04668             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    04669                 invalidationReason(),
    04670                 invalidationMessage()
    04671             ));
    04672         }
    04673
    04674         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04675                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
    04676         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    04677         return this->connection().asyncCall(callMessage, timeout);
    04678     }
    04679
    04790     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
    04791     {
    04792         if (!invalidationReason().isEmpty()) {
    04793             return QDBusPendingReply<>(QDBusMessage::createError(
    04794                 invalidationReason(),
    04795                 invalidationMessage()
    04796             ));
    04797         }
    04798
    04799         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04800                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
    04801         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    04802         return this->connection().asyncCall(callMessage, timeout);
    04803     }
    04804
    04876     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
    04877     {
    04878         if (!invalidationReason().isEmpty()) {
    04879             return QDBusPendingReply<>(QDBusMessage::createError(
    04880                 invalidationReason(),
    04881                 invalidationMessage()
    04882             ));
    04883         }
    04884
    04885         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04886                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
    04887         callMessage << QVariant::fromValue(contacts);
    04888         return this->connection().asyncCall(callMessage, timeout);
    04889     }
    04890
    04940     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
    04941     {
    04942         if (!invalidationReason().isEmpty()) {
    04943             return QDBusPendingReply<>(QDBusMessage::createError(
    04944                 invalidationReason(),
    04945                 invalidationMessage()
    04946             ));
    04947         }
    04948
    04949         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    04950                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
    04951         callMessage << QVariant::fromValue(contacts);
    04952         return this->connection().asyncCall(callMessage, timeout);
    04953     }
    04954
    04991     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
    04992     {
    04993         if (!invalidationReason().isEmpty()) {
    04994             return QDBusPendingReply<>(QDBusMessage::createError(
    04995                 invalidationReason(),
    04996                 invalidationMessage()
    04997             ));
    04998         }
    04999
    05000         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05001                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
    05002         callMessage << QVariant::fromValue(contacts);
    05003         return this->connection().asyncCall(callMessage, timeout);
    05004     }
    05005
    05042     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
    05043     {
    05044         if (!invalidationReason().isEmpty()) {
    05045             return QDBusPendingReply<>(QDBusMessage::createError(
    05046                 invalidationReason(),
    05047                 invalidationMessage()
    05048             ));
    05049         }
    05050
    05051         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05052                 this->staticInterfaceName(), QLatin1String("Unpublish"));
    05053         callMessage << QVariant::fromValue(contacts);
    05054         return this->connection().asyncCall(callMessage, timeout);
    05055     }
    05056
    05057 Q_SIGNALS:
    05067     void ContactListStateChanged(uint contactListState);
    05068
    05119     void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
    05120
    05143     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
    05144
    05145 protected:
    05146     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05147 };
    05148
    05156 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
    05157 {
    05158     Q_OBJECT
    05159
    05160 public:
    05167     static inline QLatin1String staticInterfaceName()
    05168     {
    05169         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
    05170     }
    05171
    05179     ConnectionInterfaceContactsInterface(
    05180         const QString& busName,
    05181         const QString& objectPath,
    05182         QObject* parent = 0
    05183     );
    05184
    05193     ConnectionInterfaceContactsInterface(
    05194         const QDBusConnection& connection,
    05195         const QString& busName,
    05196         const QString& objectPath,
    05197         QObject* parent = 0
    05198     );
    05199
    05206     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
    05207
    05215     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05216
    05224     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05225
    05236     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
    05237     {
    05238         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
    05239     }
    05240
    05247     Tp::PendingVariantMap *requestAllProperties() const
    05248     {
    05249         return internalRequestAllProperties();
    05250     }
    05251
    05252 public Q_SLOTS:
    05335     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
    05336     {
    05337         if (!invalidationReason().isEmpty()) {
    05338             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    05339                 invalidationReason(),
    05340                 invalidationMessage()
    05341             ));
    05342         }
    05343
    05344         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05345                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
    05346         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    05347         return this->connection().asyncCall(callMessage, timeout);
    05348     }
    05349
    05350 protected:
    05351     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05352 };
    05353
    05361 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
    05362 {
    05363     Q_OBJECT
    05364
    05365 public:
    05372     static inline QLatin1String staticInterfaceName()
    05373     {
    05374         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
    05375     }
    05376
    05384     ConnectionInterfaceLocationInterface(
    05385         const QString& busName,
    05386         const QString& objectPath,
    05387         QObject* parent = 0
    05388     );
    05389
    05398     ConnectionInterfaceLocationInterface(
    05399         const QDBusConnection& connection,
    05400         const QString& busName,
    05401         const QString& objectPath,
    05402         QObject* parent = 0
    05403     );
    05404
    05411     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
    05412
    05420     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05421
    05429     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05430
    05440     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
    05441     {
    05442         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
    05443     }
    05444
    05457     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
    05458     {
    05459         return internalRequestProperty(QLatin1String("LocationAccessControl"));
    05460     }
    05461
    05474     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
    05475     {
    05476         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
    05477     }
    05478
    05492     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
    05493     {
    05494         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
    05495     }
    05496
    05503     Tp::PendingVariantMap *requestAllProperties() const
    05504     {
    05505         return internalRequestAllProperties();
    05506     }
    05507
    05508 public Q_SLOTS:
    05549     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
    05550     {
    05551         if (!invalidationReason().isEmpty()) {
    05552             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
    05553                 invalidationReason(),
    05554                 invalidationMessage()
    05555             ));
    05556         }
    05557
    05558         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05559                 this->staticInterfaceName(), QLatin1String("GetLocations"));
    05560         callMessage << QVariant::fromValue(contacts);
    05561         return this->connection().asyncCall(callMessage, timeout);
    05562     }
    05563
    05588     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
    05589     {
    05590         if (!invalidationReason().isEmpty()) {
    05591             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
    05592                 invalidationReason(),
    05593                 invalidationMessage()
    05594             ));
    05595         }
    05596
    05597         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05598                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
    05599         callMessage << QVariant::fromValue(contact);
    05600         return this->connection().asyncCall(callMessage, timeout);
    05601     }
    05602
    05624     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
    05625     {
    05626         if (!invalidationReason().isEmpty()) {
    05627             return QDBusPendingReply<>(QDBusMessage::createError(
    05628                 invalidationReason(),
    05629                 invalidationMessage()
    05630             ));
    05631         }
    05632
    05633         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05634                 this->staticInterfaceName(), QLatin1String("SetLocation"));
    05635         callMessage << QVariant::fromValue(location);
    05636         return this->connection().asyncCall(callMessage, timeout);
    05637     }
    05638
    05639 Q_SIGNALS:
    05654     void LocationUpdated(uint contact, const QVariantMap& location);
    05655
    05656 protected:
    05657     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05658 };
    05659
    05667 class TELEPATHY_QT4_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
    05668 {
    05669     Q_OBJECT
    05670
    05671 public:
    05678     static inline QLatin1String staticInterfaceName()
    05679     {
    05680         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
    05681     }
    05682
    05690     ConnectionInterfaceMailNotificationInterface(
    05691         const QString& busName,
    05692         const QString& objectPath,
    05693         QObject* parent = 0
    05694     );
    05695
    05704     ConnectionInterfaceMailNotificationInterface(
    05705         const QDBusConnection& connection,
    05706         const QString& busName,
    05707         const QString& objectPath,
    05708         QObject* parent = 0
    05709     );
    05710
    05717     ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
    05718
    05726     explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    05727
    05735     ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    05736
    05751     inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
    05752     {
    05753         return internalRequestProperty(QLatin1String("MailNotificationFlags"));
    05754     }
    05755
    05780     inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
    05781     {
    05782         return internalRequestProperty(QLatin1String("UnreadMailCount"));
    05783     }
    05784
    05801     inline Tp::PendingVariant *requestPropertyUnreadMails() const
    05802     {
    05803         return internalRequestProperty(QLatin1String("UnreadMails"));
    05804     }
    05805
    05820     inline Tp::PendingVariant *requestPropertyMailAddress() const
    05821     {
    05822         return internalRequestProperty(QLatin1String("MailAddress"));
    05823     }
    05824
    05831     Tp::PendingVariantMap *requestAllProperties() const
    05832     {
    05833         return internalRequestAllProperties();
    05834     }
    05835
    05836 public Q_SLOTS:
    05860     inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
    05861     {
    05862         if (!invalidationReason().isEmpty()) {
    05863             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
    05864                 invalidationReason(),
    05865                 invalidationMessage()
    05866             ));
    05867         }
    05868
    05869         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05870                 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
    05871         return this->connection().asyncCall(callMessage, timeout);
    05872     }
    05873
    05903     inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
    05904     {
    05905         if (!invalidationReason().isEmpty()) {
    05906             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
    05907                 invalidationReason(),
    05908                 invalidationMessage()
    05909             ));
    05910         }
    05911
    05912         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    05913                 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
    05914         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
    05915         return this->connection().asyncCall(callMessage, timeout);
    05916     }
    05917
    05918 Q_SIGNALS:
    05941     void MailsReceived(const Tp::MailList& mails);
    05942
    05984     void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
    05985
    05986 protected:
    05987     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05988 };
    05989
    05997 class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
    05998 {
    05999     Q_OBJECT
    06000
    06001 public:
    06008     static inline QLatin1String staticInterfaceName()
    06009     {
    06010         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
    06011     }
    06012
    06020     ConnectionInterfacePowerSavingInterface(
    06021         const QString& busName,
    06022         const QString& objectPath,
    06023         QObject* parent = 0
    06024     );
    06025
    06034     ConnectionInterfacePowerSavingInterface(
    06035         const QDBusConnection& connection,
    06036         const QString& busName,
    06037         const QString& objectPath,
    06038         QObject* parent = 0
    06039     );
    06040
    06047     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
    06048
    06056     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06057
    06065     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06066
    06082     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
    06083     {
    06084         return internalRequestProperty(QLatin1String("PowerSavingActive"));
    06085     }
    06086
    06093     Tp::PendingVariantMap *requestAllProperties() const
    06094     {
    06095         return internalRequestAllProperties();
    06096     }
    06097
    06098 public Q_SLOTS:
    06132     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
    06133     {
    06134         if (!invalidationReason().isEmpty()) {
    06135             return QDBusPendingReply<>(QDBusMessage::createError(
    06136                 invalidationReason(),
    06137                 invalidationMessage()
    06138             ));
    06139         }
    06140
    06141         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06142                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
    06143         callMessage << QVariant::fromValue(activate);
    06144         return this->connection().asyncCall(callMessage, timeout);
    06145     }
    06146
    06147 Q_SIGNALS:
    06160     void PowerSavingChanged(bool active);
    06161
    06162 protected:
    06163     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06164 };
    06165
    06173 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
    06174 {
    06175     Q_OBJECT
    06176
    06177 public:
    06184     static inline QLatin1String staticInterfaceName()
    06185     {
    06186         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
    06187     }
    06188
    06196     ConnectionInterfacePresenceInterface(
    06197         const QString& busName,
    06198         const QString& objectPath,
    06199         QObject* parent = 0
    06200     );
    06201
    06210     ConnectionInterfacePresenceInterface(
    06211         const QDBusConnection& connection,
    06212         const QString& busName,
    06213         const QString& objectPath,
    06214         QObject* parent = 0
    06215     );
    06216
    06223     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
    06224
    06232     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06233
    06241     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06242
    06249     Tp::PendingVariantMap *requestAllProperties() const
    06250     {
    06251         return internalRequestAllProperties();
    06252     }
    06253
    06254 public Q_SLOTS:
    06276     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
    06277     {
    06278         if (!invalidationReason().isEmpty()) {
    06279             return QDBusPendingReply<>(QDBusMessage::createError(
    06280                 invalidationReason(),
    06281                 invalidationMessage()
    06282             ));
    06283         }
    06284
    06285         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06286                 this->staticInterfaceName(), QLatin1String("AddStatus"));
    06287         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
    06288         return this->connection().asyncCall(callMessage, timeout);
    06289     }
    06290
    06304     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
    06305     {
    06306         if (!invalidationReason().isEmpty()) {
    06307             return QDBusPendingReply<>(QDBusMessage::createError(
    06308                 invalidationReason(),
    06309                 invalidationMessage()
    06310             ));
    06311         }
    06312
    06313         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06314                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
    06315         return this->connection().asyncCall(callMessage, timeout);
    06316     }
    06317
    06341     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
    06342     {
    06343         if (!invalidationReason().isEmpty()) {
    06344             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
    06345                 invalidationReason(),
    06346                 invalidationMessage()
    06347             ));
    06348         }
    06349
    06350         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06351                 this->staticInterfaceName(), QLatin1String("GetPresence"));
    06352         callMessage << QVariant::fromValue(contacts);
    06353         return this->connection().asyncCall(callMessage, timeout);
    06354     }
    06355
    06377     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
    06378     {
    06379         if (!invalidationReason().isEmpty()) {
    06380             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
    06381                 invalidationReason(),
    06382                 invalidationMessage()
    06383             ));
    06384         }
    06385
    06386         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06387                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
    06388         return this->connection().asyncCall(callMessage, timeout);
    06389     }
    06390
    06409     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
    06410     {
    06411         if (!invalidationReason().isEmpty()) {
    06412             return QDBusPendingReply<>(QDBusMessage::createError(
    06413                 invalidationReason(),
    06414                 invalidationMessage()
    06415             ));
    06416         }
    06417
    06418         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06419                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
    06420         callMessage << QVariant::fromValue(status);
    06421         return this->connection().asyncCall(callMessage, timeout);
    06422     }
    06423
    06442     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
    06443     {
    06444         if (!invalidationReason().isEmpty()) {
    06445             return QDBusPendingReply<>(QDBusMessage::createError(
    06446                 invalidationReason(),
    06447                 invalidationMessage()
    06448             ));
    06449         }
    06450
    06451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06452                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
    06453         callMessage << QVariant::fromValue(contacts);
    06454         return this->connection().asyncCall(callMessage, timeout);
    06455     }
    06456
    06472     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
    06473     {
    06474         if (!invalidationReason().isEmpty()) {
    06475             return QDBusPendingReply<>(QDBusMessage::createError(
    06476                 invalidationReason(),
    06477                 invalidationMessage()
    06478             ));
    06479         }
    06480
    06481         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06482                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
    06483         callMessage << QVariant::fromValue(time);
    06484         return this->connection().asyncCall(callMessage, timeout);
    06485     }
    06486
    06524     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
    06525     {
    06526         if (!invalidationReason().isEmpty()) {
    06527             return QDBusPendingReply<>(QDBusMessage::createError(
    06528                 invalidationReason(),
    06529                 invalidationMessage()
    06530             ));
    06531         }
    06532
    06533         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06534                 this->staticInterfaceName(), QLatin1String("SetStatus"));
    06535         callMessage << QVariant::fromValue(statuses);
    06536         return this->connection().asyncCall(callMessage, timeout);
    06537     }
    06538
    06539 Q_SIGNALS:
    06556     void PresenceUpdate(const Tp::ContactPresences& presence);
    06557
    06558 protected:
    06559     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06560 };
    06561
    06569 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
    06570 {
    06571     Q_OBJECT
    06572
    06573 public:
    06580     static inline QLatin1String staticInterfaceName()
    06581     {
    06582         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
    06583     }
    06584
    06592     ConnectionInterfaceRequestsInterface(
    06593         const QString& busName,
    06594         const QString& objectPath,
    06595         QObject* parent = 0
    06596     );
    06597
    06606     ConnectionInterfaceRequestsInterface(
    06607         const QDBusConnection& connection,
    06608         const QString& busName,
    06609         const QString& objectPath,
    06610         QObject* parent = 0
    06611     );
    06612
    06619     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
    06620
    06628     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    06629
    06637     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    06638
    06649     inline Tp::PendingVariant *requestPropertyChannels() const
    06650     {
    06651         return internalRequestProperty(QLatin1String("Channels"));
    06652     }
    06653
    06683     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
    06684     {
    06685         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
    06686     }
    06687
    06694     Tp::PendingVariantMap *requestAllProperties() const
    06695     {
    06696         return internalRequestAllProperties();
    06697     }
    06698
    06699 public Q_SLOTS:
    06781     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
    06782     {
    06783         if (!invalidationReason().isEmpty()) {
    06784             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    06785                 invalidationReason(),
    06786                 invalidationMessage()
    06787             ));
    06788         }
    06789
    06790         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06791                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
    06792         callMessage << QVariant::fromValue(request);
    06793         return this->connection().asyncCall(callMessage, timeout);
    06794     }
    06795
    06860     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
    06861     {
    06862         if (!invalidationReason().isEmpty()) {
    06863             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    06864                 invalidationReason(),
    06865                 invalidationMessage()
    06866             ));
    06867         }
    06868
    06869         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    06870                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
    06871         callMessage << QVariant::fromValue(request);
    06872         return this->connection().asyncCall(callMessage, timeout);
    06873     }
    06874
    06875 Q_SIGNALS:
    06919     void NewChannels(const Tp::ChannelDetailsList& channels);
    06920
    06933     void ChannelClosed(const QDBusObjectPath& removed);
    06934
    06935 protected:
    06936     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    06937 };
    06938
    06946 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
    06947 {
    06948     Q_OBJECT
    06949
    06950 public:
    06957     static inline QLatin1String staticInterfaceName()
    06958     {
    06959         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
    06960     }
    06961
    06969     ConnectionInterfaceServicePointInterface(
    06970         const QString& busName,
    06971         const QString& objectPath,
    06972         QObject* parent = 0
    06973     );
    06974
    06983     ConnectionInterfaceServicePointInterface(
    06984         const QDBusConnection& connection,
    06985         const QString& busName,
    06986         const QString& objectPath,
    06987         QObject* parent = 0
    06988     );
    06989
    06996     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
    06997
    07005     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
    07006
    07014     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07015
    07027     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
    07028     {
    07029         return internalRequestProperty(QLatin1String("KnownServicePoints"));
    07030     }
    07031
    07038     Tp::PendingVariantMap *requestAllProperties() const
    07039     {
    07040         return internalRequestAllProperties();
    07041     }
    07042
    07043 Q_SIGNALS:
    07057     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
    07058
    07059 protected:
    07060     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07061 };
    07062
    07070 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
    07071 {
    07072     Q_OBJECT
    07073
    07074 public:
    07081     static inline QLatin1String staticInterfaceName()
    07082     {
    07083         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
    07084     }
    07085
    07093     ConnectionInterfaceSimplePresenceInterface(
    07094         const QString& busName,
    07095         const QString& objectPath,
    07096         QObject* parent = 0
    07097     );
    07098
    07107     ConnectionInterfaceSimplePresenceInterface(
    07108         const QDBusConnection& connection,
    07109         const QString& busName,
    07110         const QString& objectPath,
    07111         QObject* parent = 0
    07112     );
    07113
    07120     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
    07121
    07129     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    07130
    07138     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    07139
    07181     inline Tp::PendingVariant *requestPropertyStatuses() const
    07182     {
    07183         return internalRequestProperty(QLatin1String("Statuses"));
    07184     }
    07185
    07192     Tp::PendingVariantMap *requestAllProperties() const
    07193     {
    07194         return internalRequestAllProperties();
    07195     }
    07196
    07197 public Q_SLOTS:
    07261     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
    07262     {
    07263         if (!invalidationReason().isEmpty()) {
    07264             return QDBusPendingReply<>(QDBusMessage::createError(
    07265                 invalidationReason(),
    07266                 invalidationMessage()
    07267             ));
    07268         }
    07269
    07270         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07271                 this->staticInterfaceName(), QLatin1String("SetPresence"));
    07272         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
    07273         return this->connection().asyncCall(callMessage, timeout);
    07274     }
    07275
    07307     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
    07308     {
    07309         if (!invalidationReason().isEmpty()) {
    07310             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
    07311                 invalidationReason(),
    07312                 invalidationMessage()
    07313             ));
    07314         }
    07315
    07316         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
    07317                 this->staticInterfaceName(), QLatin1String("GetPresences"));
    07318         callMessage << QVariant::fromValue(contacts);
    07319         return this->connection().asyncCall(callMessage, timeout);
    07320     }
    07321
    07322 Q_SIGNALS:
    07335     void PresencesChanged(const Tp::SimpleContactPresences& presence);
    07336
    07337 protected:
    07338     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    07339 };
    07340 }
    07341 }
    07342 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
    07343 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
    07344 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
    07345 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
    07346 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
    07347 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
    07348 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
    07349 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
    07350 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
    07351 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
    07352 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
    07353 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
    07354 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
    07355 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
    07356 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
    07357 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
    07358 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
    07359 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
    07360 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
    07361 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
    07362 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)