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

Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt 0.9.3