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 
00163     inline Tp::PendingVariant *requestPropertySelfID() const
00164     {
00165         return internalRequestProperty(QLatin1String("SelfID"));
00166     }
00167 
00186     inline Tp::PendingVariant *requestPropertyStatus() const
00187     {
00188         return internalRequestProperty(QLatin1String("Status"));
00189     }
00190 
00205     inline Tp::PendingVariant *requestPropertyHasImmortalHandles() const
00206     {
00207         return internalRequestProperty(QLatin1String("HasImmortalHandles"));
00208     }
00209 
00216     Tp::PendingVariantMap *requestAllProperties() const
00217     {
00218         return internalRequestAllProperties();
00219     }
00220 
00221 public Q_SLOTS:
00239     inline QDBusPendingReply<> Connect(int timeout = -1)
00240     {
00241         if (!invalidationReason().isEmpty()) {
00242             return QDBusPendingReply<>(QDBusMessage::createError(
00243                 invalidationReason(),
00244                 invalidationMessage()
00245             ));
00246         }
00247 
00248         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00249                 this->staticInterfaceName(), QLatin1String("Connect"));
00250         return this->connection().asyncCall(callMessage, timeout);
00251     }
00252 
00265     inline QDBusPendingReply<> Disconnect(int timeout = -1)
00266     {
00267         if (!invalidationReason().isEmpty()) {
00268             return QDBusPendingReply<>(QDBusMessage::createError(
00269                 invalidationReason(),
00270                 invalidationMessage()
00271             ));
00272         }
00273 
00274         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00275                 this->staticInterfaceName(), QLatin1String("Disconnect"));
00276         return this->connection().asyncCall(callMessage, timeout);
00277     }
00278 
00297     inline QDBusPendingReply<QStringList> GetInterfaces(int timeout = -1)
00298     {
00299         if (!invalidationReason().isEmpty()) {
00300             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00301                 invalidationReason(),
00302                 invalidationMessage()
00303             ));
00304         }
00305 
00306         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00307                 this->staticInterfaceName(), QLatin1String("GetInterfaces"));
00308         return this->connection().asyncCall(callMessage, timeout);
00309     }
00310 
00325     inline QDBusPendingReply<QString> GetProtocol(int timeout = -1)
00326     {
00327         if (!invalidationReason().isEmpty()) {
00328             return QDBusPendingReply<QString>(QDBusMessage::createError(
00329                 invalidationReason(),
00330                 invalidationMessage()
00331             ));
00332         }
00333 
00334         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00335                 this->staticInterfaceName(), QLatin1String("GetProtocol"));
00336         return this->connection().asyncCall(callMessage, timeout);
00337     }
00338 
00354     inline QDBusPendingReply<uint> GetSelfHandle(int timeout = -1)
00355     {
00356         if (!invalidationReason().isEmpty()) {
00357             return QDBusPendingReply<uint>(QDBusMessage::createError(
00358                 invalidationReason(),
00359                 invalidationMessage()
00360             ));
00361         }
00362 
00363         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00364                 this->staticInterfaceName(), QLatin1String("GetSelfHandle"));
00365         return this->connection().asyncCall(callMessage, timeout);
00366     }
00367 
00382     inline QDBusPendingReply<uint> GetStatus(int timeout = -1)
00383     {
00384         if (!invalidationReason().isEmpty()) {
00385             return QDBusPendingReply<uint>(QDBusMessage::createError(
00386                 invalidationReason(),
00387                 invalidationMessage()
00388             ));
00389         }
00390 
00391         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00392                 this->staticInterfaceName(), QLatin1String("GetStatus"));
00393         return this->connection().asyncCall(callMessage, timeout);
00394     }
00395 
00438     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00439     {
00440         if (!invalidationReason().isEmpty()) {
00441             return QDBusPendingReply<>(QDBusMessage::createError(
00442                 invalidationReason(),
00443                 invalidationMessage()
00444             ));
00445         }
00446 
00447         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00448                 this->staticInterfaceName(), QLatin1String("HoldHandles"));
00449         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00450         return this->connection().asyncCall(callMessage, timeout);
00451     }
00452 
00476     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00477     {
00478         if (!invalidationReason().isEmpty()) {
00479             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00480                 invalidationReason(),
00481                 invalidationMessage()
00482             ));
00483         }
00484 
00485         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00486                 this->staticInterfaceName(), QLatin1String("InspectHandles"));
00487         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00488         return this->connection().asyncCall(callMessage, timeout);
00489     }
00490 
00505     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels(int timeout = -1)
00506     {
00507         if (!invalidationReason().isEmpty()) {
00508             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00509                 invalidationReason(),
00510                 invalidationMessage()
00511             ));
00512         }
00513 
00514         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00515                 this->staticInterfaceName(), QLatin1String("ListChannels"));
00516         return this->connection().asyncCall(callMessage, timeout);
00517     }
00518 
00544     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles, int timeout = -1)
00545     {
00546         if (!invalidationReason().isEmpty()) {
00547             return QDBusPendingReply<>(QDBusMessage::createError(
00548                 invalidationReason(),
00549                 invalidationMessage()
00550             ));
00551         }
00552 
00553         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00554                 this->staticInterfaceName(), QLatin1String("ReleaseHandles"));
00555         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00556         return this->connection().asyncCall(callMessage, timeout);
00557     }
00558 
00638     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler, int timeout = -1)
00639     {
00640         if (!invalidationReason().isEmpty()) {
00641             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00642                 invalidationReason(),
00643                 invalidationMessage()
00644             ));
00645         }
00646 
00647         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00648                 this->staticInterfaceName(), QLatin1String("RequestChannel"));
00649         callMessage << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00650         return this->connection().asyncCall(callMessage, timeout);
00651     }
00652 
00693     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers, int timeout = -1)
00694     {
00695         if (!invalidationReason().isEmpty()) {
00696             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00697                 invalidationReason(),
00698                 invalidationMessage()
00699             ));
00700         }
00701 
00702         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00703                 this->staticInterfaceName(), QLatin1String("RequestHandles"));
00704         callMessage << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00705         return this->connection().asyncCall(callMessage, timeout);
00706     }
00707 
00801     inline QDBusPendingReply<> AddClientInterest(const QStringList& tokens, int timeout = -1)
00802     {
00803         if (!invalidationReason().isEmpty()) {
00804             return QDBusPendingReply<>(QDBusMessage::createError(
00805                 invalidationReason(),
00806                 invalidationMessage()
00807             ));
00808         }
00809 
00810         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00811                 this->staticInterfaceName(), QLatin1String("AddClientInterest"));
00812         callMessage << QVariant::fromValue(tokens);
00813         return this->connection().asyncCall(callMessage, timeout);
00814     }
00815 
00847     inline QDBusPendingReply<> RemoveClientInterest(const QStringList& tokens, int timeout = -1)
00848     {
00849         if (!invalidationReason().isEmpty()) {
00850             return QDBusPendingReply<>(QDBusMessage::createError(
00851                 invalidationReason(),
00852                 invalidationMessage()
00853             ));
00854         }
00855 
00856         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
00857                 this->staticInterfaceName(), QLatin1String("RemoveClientInterest"));
00858         callMessage << QVariant::fromValue(tokens);
00859         return this->connection().asyncCall(callMessage, timeout);
00860     }
00861 
00862 Q_SIGNALS:
00874     void SelfHandleChanged(uint selfHandle);
00875 
00891     void SelfContactChanged(uint selfHandle, const QString& selfID);
00892 
00936     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00937 
01007     void ConnectionError(const QString& error, const QVariantMap& details);
01008 
01025     void StatusChanged(uint status, uint reason);
01026 
01027 protected:
01028     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01029 };
01030 
01038 class TP_QT_EXPORT ConnectionInterfaceAddressingInterface : public Tp::AbstractInterface
01039 {
01040     Q_OBJECT
01041 
01042 public:
01049     static inline QLatin1String staticInterfaceName()
01050     {
01051         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Addressing1");
01052     }
01053 
01061     ConnectionInterfaceAddressingInterface(
01062         const QString& busName,
01063         const QString& objectPath,
01064         QObject* parent = 0
01065     );
01066 
01075     ConnectionInterfaceAddressingInterface(
01076         const QDBusConnection& connection,
01077         const QString& busName,
01078         const QString& objectPath,
01079         QObject* parent = 0
01080     );
01081 
01088     ConnectionInterfaceAddressingInterface(Tp::DBusProxy *proxy);
01089 
01097     explicit ConnectionInterfaceAddressingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01098 
01106     ConnectionInterfaceAddressingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01107 
01114     Tp::PendingVariantMap *requestAllProperties() const
01115     {
01116         return internalRequestAllProperties();
01117     }
01118 
01119 public Q_SLOTS:
01209     inline QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap> GetContactsByVCardField(const QString& field, const QStringList& addresses, const QStringList& interfaces, int timeout = -1)
01210     {
01211         if (!invalidationReason().isEmpty()) {
01212             return QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap>(QDBusMessage::createError(
01213                 invalidationReason(),
01214                 invalidationMessage()
01215             ));
01216         }
01217 
01218         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01219                 this->staticInterfaceName(), QLatin1String("GetContactsByVCardField"));
01220         callMessage << QVariant::fromValue(field) << QVariant::fromValue(addresses) << QVariant::fromValue(interfaces);
01221         return this->connection().asyncCall(callMessage, timeout);
01222     }
01223 
01294     inline QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap> GetContactsByURI(const QStringList& URIs, const QStringList& interfaces, int timeout = -1)
01295     {
01296         if (!invalidationReason().isEmpty()) {
01297             return QDBusPendingReply<Tp::AddressingNormalizationMap, Tp::ContactAttributesMap>(QDBusMessage::createError(
01298                 invalidationReason(),
01299                 invalidationMessage()
01300             ));
01301         }
01302 
01303         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01304                 this->staticInterfaceName(), QLatin1String("GetContactsByURI"));
01305         callMessage << QVariant::fromValue(URIs) << QVariant::fromValue(interfaces);
01306         return this->connection().asyncCall(callMessage, timeout);
01307     }
01308 
01309 protected:
01310     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01311 };
01312 
01320 class TP_QT_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
01321 {
01322     Q_OBJECT
01323 
01324 public:
01331     static inline QLatin1String staticInterfaceName()
01332     {
01333         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Aliasing");
01334     }
01335 
01343     ConnectionInterfaceAliasingInterface(
01344         const QString& busName,
01345         const QString& objectPath,
01346         QObject* parent = 0
01347     );
01348 
01357     ConnectionInterfaceAliasingInterface(
01358         const QDBusConnection& connection,
01359         const QString& busName,
01360         const QString& objectPath,
01361         QObject* parent = 0
01362     );
01363 
01370     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
01371 
01379     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
01380 
01388     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01389 
01396     Tp::PendingVariantMap *requestAllProperties() const
01397     {
01398         return internalRequestAllProperties();
01399     }
01400 
01401 public Q_SLOTS:
01417     inline QDBusPendingReply<uint> GetAliasFlags(int timeout = -1)
01418     {
01419         if (!invalidationReason().isEmpty()) {
01420             return QDBusPendingReply<uint>(QDBusMessage::createError(
01421                 invalidationReason(),
01422                 invalidationMessage()
01423             ));
01424         }
01425 
01426         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01427                 this->staticInterfaceName(), QLatin1String("GetAliasFlags"));
01428         return this->connection().asyncCall(callMessage, timeout);
01429     }
01430 
01449     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts, int timeout = -1)
01450     {
01451         if (!invalidationReason().isEmpty()) {
01452             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01453                 invalidationReason(),
01454                 invalidationMessage()
01455             ));
01456         }
01457 
01458         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01459                 this->staticInterfaceName(), QLatin1String("RequestAliases"));
01460         callMessage << QVariant::fromValue(contacts);
01461         return this->connection().asyncCall(callMessage, timeout);
01462     }
01463 
01486     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts, int timeout = -1)
01487     {
01488         if (!invalidationReason().isEmpty()) {
01489             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
01490                 invalidationReason(),
01491                 invalidationMessage()
01492             ));
01493         }
01494 
01495         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01496                 this->staticInterfaceName(), QLatin1String("GetAliases"));
01497         callMessage << QVariant::fromValue(contacts);
01498         return this->connection().asyncCall(callMessage, timeout);
01499     }
01500 
01520     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases, int timeout = -1)
01521     {
01522         if (!invalidationReason().isEmpty()) {
01523             return QDBusPendingReply<>(QDBusMessage::createError(
01524                 invalidationReason(),
01525                 invalidationMessage()
01526             ));
01527         }
01528 
01529         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
01530                 this->staticInterfaceName(), QLatin1String("SetAliases"));
01531         callMessage << QVariant::fromValue(aliases);
01532         return this->connection().asyncCall(callMessage, timeout);
01533     }
01534 
01535 Q_SIGNALS:
01552     void AliasesChanged(const Tp::AliasPairList& aliases);
01553 
01554 protected:
01555     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01556 };
01557 
01565 class TP_QT_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
01566 {
01567     Q_OBJECT
01568 
01569 public:
01576     static inline QLatin1String staticInterfaceName()
01577     {
01578         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Anonymity");
01579     }
01580 
01588     ConnectionInterfaceAnonymityInterface(
01589         const QString& busName,
01590         const QString& objectPath,
01591         QObject* parent = 0
01592     );
01593 
01602     ConnectionInterfaceAnonymityInterface(
01603         const QDBusConnection& connection,
01604         const QString& busName,
01605         const QString& objectPath,
01606         QObject* parent = 0
01607     );
01608 
01615     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
01616 
01624     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01625 
01633     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01634 
01645     inline Tp::PendingVariant *requestPropertySupportedAnonymityModes() const
01646     {
01647         return internalRequestProperty(QLatin1String("SupportedAnonymityModes"));
01648     }
01649 
01665     inline Tp::PendingVariant *requestPropertyAnonymityMandatory() const
01666     {
01667         return internalRequestProperty(QLatin1String("AnonymityMandatory"));
01668     }
01669 
01685     inline Tp::PendingOperation *setPropertyAnonymityMandatory(bool newValue)
01686     {
01687         return internalSetProperty(QLatin1String("AnonymityMandatory"), QVariant::fromValue(newValue));
01688     }
01689 
01702     inline Tp::PendingVariant *requestPropertyAnonymityModes() const
01703     {
01704         return internalRequestProperty(QLatin1String("AnonymityModes"));
01705     }
01706 
01719     inline Tp::PendingOperation *setPropertyAnonymityModes(uint newValue)
01720     {
01721         return internalSetProperty(QLatin1String("AnonymityModes"), QVariant::fromValue(newValue));
01722     }
01723 
01730     Tp::PendingVariantMap *requestAllProperties() const
01731     {
01732         return internalRequestAllProperties();
01733     }
01734 
01735 Q_SIGNALS:
01745     void AnonymityModesChanged(uint modes);
01746 
01747 protected:
01748     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01749 };
01750 
01758 class TP_QT_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01759 {
01760     Q_OBJECT
01761 
01762 public:
01769     static inline QLatin1String staticInterfaceName()
01770     {
01771         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Avatars");
01772     }
01773 
01781     ConnectionInterfaceAvatarsInterface(
01782         const QString& busName,
01783         const QString& objectPath,
01784         QObject* parent = 0
01785     );
01786 
01795     ConnectionInterfaceAvatarsInterface(
01796         const QDBusConnection& connection,
01797         const QString& busName,
01798         const QString& objectPath,
01799         QObject* parent = 0
01800     );
01801 
01808     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01809 
01817     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01818 
01826     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01827 
01839     inline Tp::PendingVariant *requestPropertySupportedAvatarMIMETypes() const
01840     {
01841         return internalRequestProperty(QLatin1String("SupportedAvatarMIMETypes"));
01842     }
01843 
01855     inline Tp::PendingVariant *requestPropertyMinimumAvatarHeight() const
01856     {
01857         return internalRequestProperty(QLatin1String("MinimumAvatarHeight"));
01858     }
01859 
01871     inline Tp::PendingVariant *requestPropertyMinimumAvatarWidth() const
01872     {
01873         return internalRequestProperty(QLatin1String("MinimumAvatarWidth"));
01874     }
01875 
01890     inline Tp::PendingVariant *requestPropertyRecommendedAvatarHeight() const
01891     {
01892         return internalRequestProperty(QLatin1String("RecommendedAvatarHeight"));
01893     }
01894 
01907     inline Tp::PendingVariant *requestPropertyRecommendedAvatarWidth() const
01908     {
01909         return internalRequestProperty(QLatin1String("RecommendedAvatarWidth"));
01910     }
01911 
01923     inline Tp::PendingVariant *requestPropertyMaximumAvatarHeight() const
01924     {
01925         return internalRequestProperty(QLatin1String("MaximumAvatarHeight"));
01926     }
01927 
01939     inline Tp::PendingVariant *requestPropertyMaximumAvatarWidth() const
01940     {
01941         return internalRequestProperty(QLatin1String("MaximumAvatarWidth"));
01942     }
01943 
01955     inline Tp::PendingVariant *requestPropertyMaximumAvatarBytes() const
01956     {
01957         return internalRequestProperty(QLatin1String("MaximumAvatarBytes"));
01958     }
01959 
01966     Tp::PendingVariantMap *requestAllProperties() const
01967     {
01968         return internalRequestAllProperties();
01969     }
01970 
01971 public Q_SLOTS:
02006     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements(int timeout = -1)
02007     {
02008         if (!invalidationReason().isEmpty()) {
02009             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
02010                 invalidationReason(),
02011                 invalidationMessage()
02012             ));
02013         }
02014 
02015         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02016                 this->staticInterfaceName(), QLatin1String("GetAvatarRequirements"));
02017         return this->connection().asyncCall(callMessage, timeout);
02018     }
02019 
02041     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
02042     {
02043         if (!invalidationReason().isEmpty()) {
02044             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02045                 invalidationReason(),
02046                 invalidationMessage()
02047             ));
02048         }
02049 
02050         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02051                 this->staticInterfaceName(), QLatin1String("GetAvatarTokens"));
02052         callMessage << QVariant::fromValue(contacts);
02053         return this->connection().asyncCall(callMessage, timeout);
02054     }
02055 
02083     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts, int timeout = -1)
02084     {
02085         if (!invalidationReason().isEmpty()) {
02086             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
02087                 invalidationReason(),
02088                 invalidationMessage()
02089             ));
02090         }
02091 
02092         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02093                 this->staticInterfaceName(), QLatin1String("GetKnownAvatarTokens"));
02094         callMessage << QVariant::fromValue(contacts);
02095         return this->connection().asyncCall(callMessage, timeout);
02096     }
02097 
02122     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact, int timeout = -1)
02123     {
02124         if (!invalidationReason().isEmpty()) {
02125             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
02126                 invalidationReason(),
02127                 invalidationMessage()
02128             ));
02129         }
02130 
02131         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02132                 this->staticInterfaceName(), QLatin1String("RequestAvatar"));
02133         callMessage << QVariant::fromValue(contact);
02134         return this->connection().asyncCall(callMessage, timeout);
02135     }
02136 
02155     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts, int timeout = -1)
02156     {
02157         if (!invalidationReason().isEmpty()) {
02158             return QDBusPendingReply<>(QDBusMessage::createError(
02159                 invalidationReason(),
02160                 invalidationMessage()
02161             ));
02162         }
02163 
02164         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02165                 this->staticInterfaceName(), QLatin1String("RequestAvatars"));
02166         callMessage << QVariant::fromValue(contacts);
02167         return this->connection().asyncCall(callMessage, timeout);
02168     }
02169 
02193     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType, int timeout = -1)
02194     {
02195         if (!invalidationReason().isEmpty()) {
02196             return QDBusPendingReply<QString>(QDBusMessage::createError(
02197                 invalidationReason(),
02198                 invalidationMessage()
02199             ));
02200         }
02201 
02202         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02203                 this->staticInterfaceName(), QLatin1String("SetAvatar"));
02204         callMessage << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
02205         return this->connection().asyncCall(callMessage, timeout);
02206     }
02207 
02218     inline QDBusPendingReply<> ClearAvatar(int timeout = -1)
02219     {
02220         if (!invalidationReason().isEmpty()) {
02221             return QDBusPendingReply<>(QDBusMessage::createError(
02222                 invalidationReason(),
02223                 invalidationMessage()
02224             ));
02225         }
02226 
02227         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02228                 this->staticInterfaceName(), QLatin1String("ClearAvatar"));
02229         return this->connection().asyncCall(callMessage, timeout);
02230     }
02231 
02232 Q_SIGNALS:
02249     void AvatarUpdated(uint contact, const QString& newAvatarToken);
02250 
02273     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
02274 
02275 protected:
02276     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02277 };
02278 
02286 class TP_QT_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
02287 {
02288     Q_OBJECT
02289 
02290 public:
02297     static inline QLatin1String staticInterfaceName()
02298     {
02299         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Balance");
02300     }
02301 
02309     ConnectionInterfaceBalanceInterface(
02310         const QString& busName,
02311         const QString& objectPath,
02312         QObject* parent = 0
02313     );
02314 
02323     ConnectionInterfaceBalanceInterface(
02324         const QDBusConnection& connection,
02325         const QString& busName,
02326         const QString& objectPath,
02327         QObject* parent = 0
02328     );
02329 
02336     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
02337 
02345     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
02346 
02354     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02355 
02374     inline Tp::PendingVariant *requestPropertyAccountBalance() const
02375     {
02376         return internalRequestProperty(QLatin1String("AccountBalance"));
02377     }
02378 
02396     inline Tp::PendingVariant *requestPropertyManageCreditURI() const
02397     {
02398         return internalRequestProperty(QLatin1String("ManageCreditURI"));
02399     }
02400 
02407     Tp::PendingVariantMap *requestAllProperties() const
02408     {
02409         return internalRequestAllProperties();
02410     }
02411 
02412 Q_SIGNALS:
02427     void BalanceChanged(const Tp::CurrencyAmount& balance);
02428 
02429 protected:
02430     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02431 };
02432 
02440 class TP_QT_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
02441 {
02442     Q_OBJECT
02443 
02444 public:
02451     static inline QLatin1String staticInterfaceName()
02452     {
02453         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Capabilities");
02454     }
02455 
02463     ConnectionInterfaceCapabilitiesInterface(
02464         const QString& busName,
02465         const QString& objectPath,
02466         QObject* parent = 0
02467     );
02468 
02477     ConnectionInterfaceCapabilitiesInterface(
02478         const QDBusConnection& connection,
02479         const QString& busName,
02480         const QString& objectPath,
02481         QObject* parent = 0
02482     );
02483 
02490     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
02491 
02499     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02500 
02508     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02509 
02516     Tp::PendingVariantMap *requestAllProperties() const
02517     {
02518         return internalRequestAllProperties();
02519     }
02520 
02521 public Q_SLOTS:
02575     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove, int timeout = -1)
02576     {
02577         if (!invalidationReason().isEmpty()) {
02578             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
02579                 invalidationReason(),
02580                 invalidationMessage()
02581             ));
02582         }
02583 
02584         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02585                 this->staticInterfaceName(), QLatin1String("AdvertiseCapabilities"));
02586         callMessage << QVariant::fromValue(add) << QVariant::fromValue(remove);
02587         return this->connection().asyncCall(callMessage, timeout);
02588     }
02589 
02624     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles, int timeout = -1)
02625     {
02626         if (!invalidationReason().isEmpty()) {
02627             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
02628                 invalidationReason(),
02629                 invalidationMessage()
02630             ));
02631         }
02632 
02633         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
02634                 this->staticInterfaceName(), QLatin1String("GetCapabilities"));
02635         callMessage << QVariant::fromValue(handles);
02636         return this->connection().asyncCall(callMessage, timeout);
02637     }
02638 
02639 Q_SIGNALS:
02666     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
02667 
02668 protected:
02669     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02670 };
02671 
02679 class TP_QT_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
02680 {
02681     Q_OBJECT
02682 
02683 public:
02690     static inline QLatin1String staticInterfaceName()
02691     {
02692         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Cellular");
02693     }
02694 
02702     ConnectionInterfaceCellularInterface(
02703         const QString& busName,
02704         const QString& objectPath,
02705         QObject* parent = 0
02706     );
02707 
02716     ConnectionInterfaceCellularInterface(
02717         const QDBusConnection& connection,
02718         const QString& busName,
02719         const QString& objectPath,
02720         QObject* parent = 0
02721     );
02722 
02729     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02730 
02738     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02739 
02747     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02748 
02767     inline Tp::PendingVariant *requestPropertyMessageValidityPeriod() const
02768     {
02769         return internalRequestProperty(QLatin1String("MessageValidityPeriod"));
02770     }
02771 
02790     inline Tp::PendingOperation *setPropertyMessageValidityPeriod(uint newValue)
02791     {
02792         return internalSetProperty(QLatin1String("MessageValidityPeriod"), QVariant::fromValue(newValue));
02793     }
02794 
02817     inline Tp::PendingVariant *requestPropertyOverrideMessageServiceCentre() const
02818     {
02819         return internalRequestProperty(QLatin1String("OverrideMessageServiceCentre"));
02820     }
02821 
02844     inline Tp::PendingOperation *setPropertyOverrideMessageServiceCentre(bool newValue)
02845     {
02846         return internalSetProperty(QLatin1String("OverrideMessageServiceCentre"), QVariant::fromValue(newValue));
02847     }
02848 
02865     inline Tp::PendingVariant *requestPropertyMessageServiceCentre() const
02866     {
02867         return internalRequestProperty(QLatin1String("MessageServiceCentre"));
02868     }
02869 
02886     inline Tp::PendingOperation *setPropertyMessageServiceCentre(QString newValue)
02887     {
02888         return internalSetProperty(QLatin1String("MessageServiceCentre"), QVariant::fromValue(newValue));
02889     }
02890 
02904     inline Tp::PendingVariant *requestPropertyIMSI() const
02905     {
02906         return internalRequestProperty(QLatin1String("IMSI"));
02907     }
02908 
02927     inline Tp::PendingVariant *requestPropertyMessageReducedCharacterSet() const
02928     {
02929         return internalRequestProperty(QLatin1String("MessageReducedCharacterSet"));
02930     }
02931 
02950     inline Tp::PendingOperation *setPropertyMessageReducedCharacterSet(bool newValue)
02951     {
02952         return internalSetProperty(QLatin1String("MessageReducedCharacterSet"), QVariant::fromValue(newValue));
02953     }
02954 
02980     inline Tp::PendingVariant *requestPropertyMessageNationalCharacterSet() const
02981     {
02982         return internalRequestProperty(QLatin1String("MessageNationalCharacterSet"));
02983     }
02984 
03010     inline Tp::PendingOperation *setPropertyMessageNationalCharacterSet(QString newValue)
03011     {
03012         return internalSetProperty(QLatin1String("MessageNationalCharacterSet"), QVariant::fromValue(newValue));
03013     }
03014 
03021     Tp::PendingVariantMap *requestAllProperties() const
03022     {
03023         return internalRequestAllProperties();
03024     }
03025 
03026 Q_SIGNALS:
03042     void IMSIChanged(const QString& IMSI);
03043 
03044 protected:
03045     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03046 };
03047 
03055 class TP_QT_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
03056 {
03057     Q_OBJECT
03058 
03059 public:
03066     static inline QLatin1String staticInterfaceName()
03067     {
03068         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ClientTypes");
03069     }
03070 
03078     ConnectionInterfaceClientTypesInterface(
03079         const QString& busName,
03080         const QString& objectPath,
03081         QObject* parent = 0
03082     );
03083 
03092     ConnectionInterfaceClientTypesInterface(
03093         const QDBusConnection& connection,
03094         const QString& busName,
03095         const QString& objectPath,
03096         QObject* parent = 0
03097     );
03098 
03105     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
03106 
03114     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03115 
03123     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03124 
03131     Tp::PendingVariantMap *requestAllProperties() const
03132     {
03133         return internalRequestAllProperties();
03134     }
03135 
03136 public Q_SLOTS:
03165     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts, int timeout = -1)
03166     {
03167         if (!invalidationReason().isEmpty()) {
03168             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
03169                 invalidationReason(),
03170                 invalidationMessage()
03171             ));
03172         }
03173 
03174         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03175                 this->staticInterfaceName(), QLatin1String("GetClientTypes"));
03176         callMessage << QVariant::fromValue(contacts);
03177         return this->connection().asyncCall(callMessage, timeout);
03178     }
03179 
03204     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact, int timeout = -1)
03205     {
03206         if (!invalidationReason().isEmpty()) {
03207             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
03208                 invalidationReason(),
03209                 invalidationMessage()
03210             ));
03211         }
03212 
03213         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03214                 this->staticInterfaceName(), QLatin1String("RequestClientTypes"));
03215         callMessage << QVariant::fromValue(contact);
03216         return this->connection().asyncCall(callMessage, timeout);
03217     }
03218 
03219 Q_SIGNALS:
03234     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
03235 
03236 protected:
03237     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03238 };
03239 
03247 class TP_QT_EXPORT ConnectionInterfaceContactBlockingInterface : public Tp::AbstractInterface
03248 {
03249     Q_OBJECT
03250 
03251 public:
03258     static inline QLatin1String staticInterfaceName()
03259     {
03260         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactBlocking");
03261     }
03262 
03270     ConnectionInterfaceContactBlockingInterface(
03271         const QString& busName,
03272         const QString& objectPath,
03273         QObject* parent = 0
03274     );
03275 
03284     ConnectionInterfaceContactBlockingInterface(
03285         const QDBusConnection& connection,
03286         const QString& busName,
03287         const QString& objectPath,
03288         QObject* parent = 0
03289     );
03290 
03297     ConnectionInterfaceContactBlockingInterface(Tp::DBusProxy *proxy);
03298 
03306     explicit ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface);
03307 
03315     ConnectionInterfaceContactBlockingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03316 
03333     inline Tp::PendingVariant *requestPropertyContactBlockingCapabilities() const
03334     {
03335         return internalRequestProperty(QLatin1String("ContactBlockingCapabilities"));
03336     }
03337 
03344     Tp::PendingVariantMap *requestAllProperties() const
03345     {
03346         return internalRequestAllProperties();
03347     }
03348 
03349 public Q_SLOTS:
03409     inline QDBusPendingReply<> BlockContacts(const Tp::UIntList& contacts, bool reportAbusive, int timeout = -1)
03410     {
03411         if (!invalidationReason().isEmpty()) {
03412             return QDBusPendingReply<>(QDBusMessage::createError(
03413                 invalidationReason(),
03414                 invalidationMessage()
03415             ));
03416         }
03417 
03418         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03419                 this->staticInterfaceName(), QLatin1String("BlockContacts"));
03420         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(reportAbusive);
03421         return this->connection().asyncCall(callMessage, timeout);
03422     }
03423 
03442     inline QDBusPendingReply<> UnblockContacts(const Tp::UIntList& contacts, int timeout = -1)
03443     {
03444         if (!invalidationReason().isEmpty()) {
03445             return QDBusPendingReply<>(QDBusMessage::createError(
03446                 invalidationReason(),
03447                 invalidationMessage()
03448             ));
03449         }
03450 
03451         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03452                 this->staticInterfaceName(), QLatin1String("UnblockContacts"));
03453         callMessage << QVariant::fromValue(contacts);
03454         return this->connection().asyncCall(callMessage, timeout);
03455     }
03456 
03477     inline QDBusPendingReply<Tp::HandleIdentifierMap> RequestBlockedContacts(int timeout = -1)
03478     {
03479         if (!invalidationReason().isEmpty()) {
03480             return QDBusPendingReply<Tp::HandleIdentifierMap>(QDBusMessage::createError(
03481                 invalidationReason(),
03482                 invalidationMessage()
03483             ));
03484         }
03485 
03486         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03487                 this->staticInterfaceName(), QLatin1String("RequestBlockedContacts"));
03488         return this->connection().asyncCall(callMessage, timeout);
03489     }
03490 
03491 Q_SIGNALS:
03510     void BlockedContactsChanged(const Tp::HandleIdentifierMap& blockedContacts, const Tp::HandleIdentifierMap& unblockedContacts);
03511 
03512 protected:
03513     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03514 };
03515 
03523 class TP_QT_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
03524 {
03525     Q_OBJECT
03526 
03527 public:
03534     static inline QLatin1String staticInterfaceName()
03535     {
03536         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities");
03537     }
03538 
03546     ConnectionInterfaceContactCapabilitiesInterface(
03547         const QString& busName,
03548         const QString& objectPath,
03549         QObject* parent = 0
03550     );
03551 
03560     ConnectionInterfaceContactCapabilitiesInterface(
03561         const QDBusConnection& connection,
03562         const QString& busName,
03563         const QString& objectPath,
03564         QObject* parent = 0
03565     );
03566 
03573     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
03574 
03582     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
03583 
03591     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03592 
03599     Tp::PendingVariantMap *requestAllProperties() const
03600     {
03601         return internalRequestAllProperties();
03602     }
03603 
03604 public Q_SLOTS:
03667     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities, int timeout = -1)
03668     {
03669         if (!invalidationReason().isEmpty()) {
03670             return QDBusPendingReply<>(QDBusMessage::createError(
03671                 invalidationReason(),
03672                 invalidationMessage()
03673             ));
03674         }
03675 
03676         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03677                 this->staticInterfaceName(), QLatin1String("UpdateCapabilities"));
03678         callMessage << QVariant::fromValue(handlerCapabilities);
03679         return this->connection().asyncCall(callMessage, timeout);
03680     }
03681 
03717     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles, int timeout = -1)
03718     {
03719         if (!invalidationReason().isEmpty()) {
03720             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
03721                 invalidationReason(),
03722                 invalidationMessage()
03723             ));
03724         }
03725 
03726         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03727                 this->staticInterfaceName(), QLatin1String("GetContactCapabilities"));
03728         callMessage << QVariant::fromValue(handles);
03729         return this->connection().asyncCall(callMessage, timeout);
03730     }
03731 
03732 Q_SIGNALS:
03753     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
03754 
03755 protected:
03756     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03757 };
03758 
03766 class TP_QT_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
03767 {
03768     Q_OBJECT
03769 
03770 public:
03777     static inline QLatin1String staticInterfaceName()
03778     {
03779         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactGroups");
03780     }
03781 
03789     ConnectionInterfaceContactGroupsInterface(
03790         const QString& busName,
03791         const QString& objectPath,
03792         QObject* parent = 0
03793     );
03794 
03803     ConnectionInterfaceContactGroupsInterface(
03804         const QDBusConnection& connection,
03805         const QString& busName,
03806         const QString& objectPath,
03807         QObject* parent = 0
03808     );
03809 
03816     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
03817 
03825     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03826 
03834     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03835 
03852     inline Tp::PendingVariant *requestPropertyDisjointGroups() const
03853     {
03854         return internalRequestProperty(QLatin1String("DisjointGroups"));
03855     }
03856 
03869     inline Tp::PendingVariant *requestPropertyGroupStorage() const
03870     {
03871         return internalRequestProperty(QLatin1String("GroupStorage"));
03872     }
03873 
03897     inline Tp::PendingVariant *requestPropertyGroups() const
03898     {
03899         return internalRequestProperty(QLatin1String("Groups"));
03900     }
03901 
03908     Tp::PendingVariantMap *requestAllProperties() const
03909     {
03910         return internalRequestAllProperties();
03911     }
03912 
03913 public Q_SLOTS:
03962     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups, int timeout = -1)
03963     {
03964         if (!invalidationReason().isEmpty()) {
03965             return QDBusPendingReply<>(QDBusMessage::createError(
03966                 invalidationReason(),
03967                 invalidationMessage()
03968             ));
03969         }
03970 
03971         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
03972                 this->staticInterfaceName(), QLatin1String("SetContactGroups"));
03973         callMessage << QVariant::fromValue(contact) << QVariant::fromValue(groups);
03974         return this->connection().asyncCall(callMessage, timeout);
03975     }
03976 
04024     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members, int timeout = -1)
04025     {
04026         if (!invalidationReason().isEmpty()) {
04027             return QDBusPendingReply<>(QDBusMessage::createError(
04028                 invalidationReason(),
04029                 invalidationMessage()
04030             ));
04031         }
04032 
04033         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04034                 this->staticInterfaceName(), QLatin1String("SetGroupMembers"));
04035         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
04036         return this->connection().asyncCall(callMessage, timeout);
04037     }
04038 
04079     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
04080     {
04081         if (!invalidationReason().isEmpty()) {
04082             return QDBusPendingReply<>(QDBusMessage::createError(
04083                 invalidationReason(),
04084                 invalidationMessage()
04085             ));
04086         }
04087 
04088         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04089                 this->staticInterfaceName(), QLatin1String("AddToGroup"));
04090         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
04091         return this->connection().asyncCall(callMessage, timeout);
04092     }
04093 
04133     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members, int timeout = -1)
04134     {
04135         if (!invalidationReason().isEmpty()) {
04136             return QDBusPendingReply<>(QDBusMessage::createError(
04137                 invalidationReason(),
04138                 invalidationMessage()
04139             ));
04140         }
04141 
04142         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04143                 this->staticInterfaceName(), QLatin1String("RemoveFromGroup"));
04144         callMessage << QVariant::fromValue(group) << QVariant::fromValue(members);
04145         return this->connection().asyncCall(callMessage, timeout);
04146     }
04147 
04176     inline QDBusPendingReply<> RemoveGroup(const QString& group, int timeout = -1)
04177     {
04178         if (!invalidationReason().isEmpty()) {
04179             return QDBusPendingReply<>(QDBusMessage::createError(
04180                 invalidationReason(),
04181                 invalidationMessage()
04182             ));
04183         }
04184 
04185         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04186                 this->staticInterfaceName(), QLatin1String("RemoveGroup"));
04187         callMessage << QVariant::fromValue(group);
04188         return this->connection().asyncCall(callMessage, timeout);
04189     }
04190 
04230     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName, int timeout = -1)
04231     {
04232         if (!invalidationReason().isEmpty()) {
04233             return QDBusPendingReply<>(QDBusMessage::createError(
04234                 invalidationReason(),
04235                 invalidationMessage()
04236             ));
04237         }
04238 
04239         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04240                 this->staticInterfaceName(), QLatin1String("RenameGroup"));
04241         callMessage << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
04242         return this->connection().asyncCall(callMessage, timeout);
04243     }
04244 
04245 Q_SIGNALS:
04263     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
04264 
04275     void GroupsCreated(const QStringList& names);
04276 
04324     void GroupRenamed(const QString& oldName, const QString& newName);
04325 
04352     void GroupsRemoved(const QStringList& names);
04353 
04354 protected:
04355     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04356 };
04357 
04365 class TP_QT_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
04366 {
04367     Q_OBJECT
04368 
04369 public:
04376     static inline QLatin1String staticInterfaceName()
04377     {
04378         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactInfo");
04379     }
04380 
04388     ConnectionInterfaceContactInfoInterface(
04389         const QString& busName,
04390         const QString& objectPath,
04391         QObject* parent = 0
04392     );
04393 
04402     ConnectionInterfaceContactInfoInterface(
04403         const QDBusConnection& connection,
04404         const QString& busName,
04405         const QString& objectPath,
04406         QObject* parent = 0
04407     );
04408 
04415     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
04416 
04424     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
04425 
04433     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04434 
04458     inline Tp::PendingVariant *requestPropertyContactInfoFlags() const
04459     {
04460         return internalRequestProperty(QLatin1String("ContactInfoFlags"));
04461     }
04462 
04520     inline Tp::PendingVariant *requestPropertySupportedFields() const
04521     {
04522         return internalRequestProperty(QLatin1String("SupportedFields"));
04523     }
04524 
04531     Tp::PendingVariantMap *requestAllProperties() const
04532     {
04533         return internalRequestAllProperties();
04534     }
04535 
04536 public Q_SLOTS:
04559     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04560     {
04561         if (!invalidationReason().isEmpty()) {
04562             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
04563                 invalidationReason(),
04564                 invalidationMessage()
04565             ));
04566         }
04567 
04568         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04569                 this->staticInterfaceName(), QLatin1String("GetContactInfo"));
04570         callMessage << QVariant::fromValue(contacts);
04571         return this->connection().asyncCall(callMessage, timeout);
04572     }
04573 
04593     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts, int timeout = -1)
04594     {
04595         if (!invalidationReason().isEmpty()) {
04596             return QDBusPendingReply<>(QDBusMessage::createError(
04597                 invalidationReason(),
04598                 invalidationMessage()
04599             ));
04600         }
04601 
04602         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04603                 this->staticInterfaceName(), QLatin1String("RefreshContactInfo"));
04604         callMessage << QVariant::fromValue(contacts);
04605         return this->connection().asyncCall(callMessage, timeout);
04606     }
04607 
04629     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact, int timeout = -1)
04630     {
04631         if (!invalidationReason().isEmpty()) {
04632             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
04633                 invalidationReason(),
04634                 invalidationMessage()
04635             ));
04636         }
04637 
04638         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04639                 this->staticInterfaceName(), QLatin1String("RequestContactInfo"));
04640         callMessage << QVariant::fromValue(contact);
04641         return this->connection().asyncCall(callMessage, timeout);
04642     }
04643 
04661     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo, int timeout = -1)
04662     {
04663         if (!invalidationReason().isEmpty()) {
04664             return QDBusPendingReply<>(QDBusMessage::createError(
04665                 invalidationReason(),
04666                 invalidationMessage()
04667             ));
04668         }
04669 
04670         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
04671                 this->staticInterfaceName(), QLatin1String("SetContactInfo"));
04672         callMessage << QVariant::fromValue(contactInfo);
04673         return this->connection().asyncCall(callMessage, timeout);
04674     }
04675 
04676 Q_SIGNALS:
04693     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
04694 
04695 protected:
04696     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04697 };
04698 
04706 class TP_QT_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
04707 {
04708     Q_OBJECT
04709 
04710 public:
04717     static inline QLatin1String staticInterfaceName()
04718     {
04719         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ContactList");
04720     }
04721 
04729     ConnectionInterfaceContactListInterface(
04730         const QString& busName,
04731         const QString& objectPath,
04732         QObject* parent = 0
04733     );
04734 
04743     ConnectionInterfaceContactListInterface(
04744         const QDBusConnection& connection,
04745         const QString& busName,
04746         const QString& objectPath,
04747         QObject* parent = 0
04748     );
04749 
04756     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
04757 
04765     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
04766 
04774     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04775 
04786     inline Tp::PendingVariant *requestPropertyContactListState() const
04787     {
04788         return internalRequestProperty(QLatin1String("ContactListState"));
04789     }
04790 
04850     inline Tp::PendingVariant *requestPropertyContactListPersists() const
04851     {
04852         return internalRequestProperty(QLatin1String("ContactListPersists"));
04853     }
04854 
04883     inline Tp::PendingVariant *requestPropertyCanChangeContactList() const
04884     {
04885         return internalRequestProperty(QLatin1String("CanChangeContactList"));
04886     }
04887 
04916     inline Tp::PendingVariant *requestPropertyRequestUsesMessage() const
04917     {
04918         return internalRequestProperty(QLatin1String("RequestUsesMessage"));
04919     }
04920 
04952     inline Tp::PendingVariant *requestPropertyDownloadAtConnection() const
04953     {
04954         return internalRequestProperty(QLatin1String("DownloadAtConnection"));
04955     }
04956 
04963     Tp::PendingVariantMap *requestAllProperties() const
04964     {
04965         return internalRequestAllProperties();
04966     }
04967 
04968 public Q_SLOTS:
05040     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold, int timeout = -1)
05041     {
05042         if (!invalidationReason().isEmpty()) {
05043             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05044                 invalidationReason(),
05045                 invalidationMessage()
05046             ));
05047         }
05048 
05049         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05050                 this->staticInterfaceName(), QLatin1String("GetContactListAttributes"));
05051         callMessage << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05052         return this->connection().asyncCall(callMessage, timeout);
05053     }
05054 
05165     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message, int timeout = -1)
05166     {
05167         if (!invalidationReason().isEmpty()) {
05168             return QDBusPendingReply<>(QDBusMessage::createError(
05169                 invalidationReason(),
05170                 invalidationMessage()
05171             ));
05172         }
05173 
05174         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05175                 this->staticInterfaceName(), QLatin1String("RequestSubscription"));
05176         callMessage << QVariant::fromValue(contacts) << QVariant::fromValue(message);
05177         return this->connection().asyncCall(callMessage, timeout);
05178     }
05179 
05251     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts, int timeout = -1)
05252     {
05253         if (!invalidationReason().isEmpty()) {
05254             return QDBusPendingReply<>(QDBusMessage::createError(
05255                 invalidationReason(),
05256                 invalidationMessage()
05257             ));
05258         }
05259 
05260         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05261                 this->staticInterfaceName(), QLatin1String("AuthorizePublication"));
05262         callMessage << QVariant::fromValue(contacts);
05263         return this->connection().asyncCall(callMessage, timeout);
05264     }
05265 
05315     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts, int timeout = -1)
05316     {
05317         if (!invalidationReason().isEmpty()) {
05318             return QDBusPendingReply<>(QDBusMessage::createError(
05319                 invalidationReason(),
05320                 invalidationMessage()
05321             ));
05322         }
05323 
05324         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05325                 this->staticInterfaceName(), QLatin1String("RemoveContacts"));
05326         callMessage << QVariant::fromValue(contacts);
05327         return this->connection().asyncCall(callMessage, timeout);
05328     }
05329 
05366     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts, int timeout = -1)
05367     {
05368         if (!invalidationReason().isEmpty()) {
05369             return QDBusPendingReply<>(QDBusMessage::createError(
05370                 invalidationReason(),
05371                 invalidationMessage()
05372             ));
05373         }
05374 
05375         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05376                 this->staticInterfaceName(), QLatin1String("Unsubscribe"));
05377         callMessage << QVariant::fromValue(contacts);
05378         return this->connection().asyncCall(callMessage, timeout);
05379     }
05380 
05417     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts, int timeout = -1)
05418     {
05419         if (!invalidationReason().isEmpty()) {
05420             return QDBusPendingReply<>(QDBusMessage::createError(
05421                 invalidationReason(),
05422                 invalidationMessage()
05423             ));
05424         }
05425 
05426         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05427                 this->staticInterfaceName(), QLatin1String("Unpublish"));
05428         callMessage << QVariant::fromValue(contacts);
05429         return this->connection().asyncCall(callMessage, timeout);
05430     }
05431 
05446     inline QDBusPendingReply<> Download(int timeout = -1)
05447     {
05448         if (!invalidationReason().isEmpty()) {
05449             return QDBusPendingReply<>(QDBusMessage::createError(
05450                 invalidationReason(),
05451                 invalidationMessage()
05452             ));
05453         }
05454 
05455         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05456                 this->staticInterfaceName(), QLatin1String("Download"));
05457         return this->connection().asyncCall(callMessage, timeout);
05458     }
05459 
05460 Q_SIGNALS:
05470     void ContactListStateChanged(uint contactListState);
05471 
05522     void ContactsChangedWithID(const Tp::ContactSubscriptionMap& changes, const Tp::HandleIdentifierMap& identifiers, const Tp::HandleIdentifierMap& removals);
05523 
05546     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
05547 
05548 protected:
05549     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05550 };
05551 
05559 class TP_QT_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
05560 {
05561     Q_OBJECT
05562 
05563 public:
05570     static inline QLatin1String staticInterfaceName()
05571     {
05572         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Contacts");
05573     }
05574 
05582     ConnectionInterfaceContactsInterface(
05583         const QString& busName,
05584         const QString& objectPath,
05585         QObject* parent = 0
05586     );
05587 
05596     ConnectionInterfaceContactsInterface(
05597         const QDBusConnection& connection,
05598         const QString& busName,
05599         const QString& objectPath,
05600         QObject* parent = 0
05601     );
05602 
05609     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
05610 
05618     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05619 
05627     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05628 
05639     inline Tp::PendingVariant *requestPropertyContactAttributeInterfaces() const
05640     {
05641         return internalRequestProperty(QLatin1String("ContactAttributeInterfaces"));
05642     }
05643 
05650     Tp::PendingVariantMap *requestAllProperties() const
05651     {
05652         return internalRequestAllProperties();
05653     }
05654 
05655 public Q_SLOTS:
05738     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold, int timeout = -1)
05739     {
05740         if (!invalidationReason().isEmpty()) {
05741             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
05742                 invalidationReason(),
05743                 invalidationMessage()
05744             ));
05745         }
05746 
05747         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05748                 this->staticInterfaceName(), QLatin1String("GetContactAttributes"));
05749         callMessage << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
05750         return this->connection().asyncCall(callMessage, timeout);
05751     }
05752 
05801     inline QDBusPendingReply<uint, QVariantMap> GetContactByID(const QString& identifier, const QStringList& interfaces, int timeout = -1)
05802     {
05803         if (!invalidationReason().isEmpty()) {
05804             return QDBusPendingReply<uint, QVariantMap>(QDBusMessage::createError(
05805                 invalidationReason(),
05806                 invalidationMessage()
05807             ));
05808         }
05809 
05810         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
05811                 this->staticInterfaceName(), QLatin1String("GetContactByID"));
05812         callMessage << QVariant::fromValue(identifier) << QVariant::fromValue(interfaces);
05813         return this->connection().asyncCall(callMessage, timeout);
05814     }
05815 
05816 protected:
05817     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05818 };
05819 
05827 class TP_QT_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
05828 {
05829     Q_OBJECT
05830 
05831 public:
05838     static inline QLatin1String staticInterfaceName()
05839     {
05840         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Location");
05841     }
05842 
05850     ConnectionInterfaceLocationInterface(
05851         const QString& busName,
05852         const QString& objectPath,
05853         QObject* parent = 0
05854     );
05855 
05864     ConnectionInterfaceLocationInterface(
05865         const QDBusConnection& connection,
05866         const QString& busName,
05867         const QString& objectPath,
05868         QObject* parent = 0
05869     );
05870 
05877     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
05878 
05886     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
05887 
05895     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05896 
05906     inline Tp::PendingVariant *requestPropertyLocationAccessControlTypes() const
05907     {
05908         return internalRequestProperty(QLatin1String("LocationAccessControlTypes"));
05909     }
05910 
05923     inline Tp::PendingVariant *requestPropertyLocationAccessControl() const
05924     {
05925         return internalRequestProperty(QLatin1String("LocationAccessControl"));
05926     }
05927 
05940     inline Tp::PendingOperation *setPropertyLocationAccessControl(Tp::RichPresenceAccessControl newValue)
05941     {
05942         return internalSetProperty(QLatin1String("LocationAccessControl"), QVariant::fromValue(newValue));
05943     }
05944 
05958     inline Tp::PendingVariant *requestPropertySupportedLocationFeatures() const
05959     {
05960         return internalRequestProperty(QLatin1String("SupportedLocationFeatures"));
05961     }
05962 
05969     Tp::PendingVariantMap *requestAllProperties() const
05970     {
05971         return internalRequestAllProperties();
05972     }
05973 
05974 public Q_SLOTS:
06015     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts, int timeout = -1)
06016     {
06017         if (!invalidationReason().isEmpty()) {
06018             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
06019                 invalidationReason(),
06020                 invalidationMessage()
06021             ));
06022         }
06023 
06024         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06025                 this->staticInterfaceName(), QLatin1String("GetLocations"));
06026         callMessage << QVariant::fromValue(contacts);
06027         return this->connection().asyncCall(callMessage, timeout);
06028     }
06029 
06054     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact, int timeout = -1)
06055     {
06056         if (!invalidationReason().isEmpty()) {
06057             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
06058                 invalidationReason(),
06059                 invalidationMessage()
06060             ));
06061         }
06062 
06063         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06064                 this->staticInterfaceName(), QLatin1String("RequestLocation"));
06065         callMessage << QVariant::fromValue(contact);
06066         return this->connection().asyncCall(callMessage, timeout);
06067     }
06068 
06090     inline QDBusPendingReply<> SetLocation(const QVariantMap& location, int timeout = -1)
06091     {
06092         if (!invalidationReason().isEmpty()) {
06093             return QDBusPendingReply<>(QDBusMessage::createError(
06094                 invalidationReason(),
06095                 invalidationMessage()
06096             ));
06097         }
06098 
06099         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06100                 this->staticInterfaceName(), QLatin1String("SetLocation"));
06101         callMessage << QVariant::fromValue(location);
06102         return this->connection().asyncCall(callMessage, timeout);
06103     }
06104 
06105 Q_SIGNALS:
06120     void LocationUpdated(uint contact, const QVariantMap& location);
06121 
06122 protected:
06123     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06124 };
06125 
06133 class TP_QT_EXPORT ConnectionInterfaceMailNotificationInterface : public Tp::AbstractInterface
06134 {
06135     Q_OBJECT
06136 
06137 public:
06144     static inline QLatin1String staticInterfaceName()
06145     {
06146         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.MailNotification");
06147     }
06148 
06156     ConnectionInterfaceMailNotificationInterface(
06157         const QString& busName,
06158         const QString& objectPath,
06159         QObject* parent = 0
06160     );
06161 
06170     ConnectionInterfaceMailNotificationInterface(
06171         const QDBusConnection& connection,
06172         const QString& busName,
06173         const QString& objectPath,
06174         QObject* parent = 0
06175     );
06176 
06183     ConnectionInterfaceMailNotificationInterface(Tp::DBusProxy *proxy);
06184 
06192     explicit ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface);
06193 
06201     ConnectionInterfaceMailNotificationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06202 
06217     inline Tp::PendingVariant *requestPropertyMailNotificationFlags() const
06218     {
06219         return internalRequestProperty(QLatin1String("MailNotificationFlags"));
06220     }
06221 
06246     inline Tp::PendingVariant *requestPropertyUnreadMailCount() const
06247     {
06248         return internalRequestProperty(QLatin1String("UnreadMailCount"));
06249     }
06250 
06267     inline Tp::PendingVariant *requestPropertyUnreadMails() const
06268     {
06269         return internalRequestProperty(QLatin1String("UnreadMails"));
06270     }
06271 
06286     inline Tp::PendingVariant *requestPropertyMailAddress() const
06287     {
06288         return internalRequestProperty(QLatin1String("MailAddress"));
06289     }
06290 
06297     Tp::PendingVariantMap *requestAllProperties() const
06298     {
06299         return internalRequestAllProperties();
06300     }
06301 
06302 public Q_SLOTS:
06326     inline QDBusPendingReply<Tp::MailURL> RequestInboxURL(int timeout = -1)
06327     {
06328         if (!invalidationReason().isEmpty()) {
06329             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
06330                 invalidationReason(),
06331                 invalidationMessage()
06332             ));
06333         }
06334 
06335         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06336                 this->staticInterfaceName(), QLatin1String("RequestInboxURL"));
06337         return this->connection().asyncCall(callMessage, timeout);
06338     }
06339 
06369     inline QDBusPendingReply<Tp::MailURL> RequestMailURL(const QString& ID, const QDBusVariant& URLData, int timeout = -1)
06370     {
06371         if (!invalidationReason().isEmpty()) {
06372             return QDBusPendingReply<Tp::MailURL>(QDBusMessage::createError(
06373                 invalidationReason(),
06374                 invalidationMessage()
06375             ));
06376         }
06377 
06378         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06379                 this->staticInterfaceName(), QLatin1String("RequestMailURL"));
06380         callMessage << QVariant::fromValue(ID) << QVariant::fromValue(URLData);
06381         return this->connection().asyncCall(callMessage, timeout);
06382     }
06383 
06384 Q_SIGNALS:
06407     void MailsReceived(const Tp::MailList& mails);
06408 
06450     void UnreadMailsChanged(uint count, const Tp::MailList& mailsAdded, const QStringList& mailsRemoved);
06451 
06452 protected:
06453     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06454 };
06455 
06463 class TP_QT_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
06464 {
06465     Q_OBJECT
06466 
06467 public:
06474     static inline QLatin1String staticInterfaceName()
06475     {
06476         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.PowerSaving");
06477     }
06478 
06486     ConnectionInterfacePowerSavingInterface(
06487         const QString& busName,
06488         const QString& objectPath,
06489         QObject* parent = 0
06490     );
06491 
06500     ConnectionInterfacePowerSavingInterface(
06501         const QDBusConnection& connection,
06502         const QString& busName,
06503         const QString& objectPath,
06504         QObject* parent = 0
06505     );
06506 
06513     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
06514 
06522     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
06523 
06531     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06532 
06548     inline Tp::PendingVariant *requestPropertyPowerSavingActive() const
06549     {
06550         return internalRequestProperty(QLatin1String("PowerSavingActive"));
06551     }
06552 
06559     Tp::PendingVariantMap *requestAllProperties() const
06560     {
06561         return internalRequestAllProperties();
06562     }
06563 
06564 public Q_SLOTS:
06598     inline QDBusPendingReply<> SetPowerSaving(bool activate, int timeout = -1)
06599     {
06600         if (!invalidationReason().isEmpty()) {
06601             return QDBusPendingReply<>(QDBusMessage::createError(
06602                 invalidationReason(),
06603                 invalidationMessage()
06604             ));
06605         }
06606 
06607         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06608                 this->staticInterfaceName(), QLatin1String("SetPowerSaving"));
06609         callMessage << QVariant::fromValue(activate);
06610         return this->connection().asyncCall(callMessage, timeout);
06611     }
06612 
06613 Q_SIGNALS:
06626     void PowerSavingChanged(bool active);
06627 
06628 protected:
06629     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06630 };
06631 
06639 class TP_QT_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
06640 {
06641     Q_OBJECT
06642 
06643 public:
06650     static inline QLatin1String staticInterfaceName()
06651     {
06652         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Presence");
06653     }
06654 
06662     ConnectionInterfacePresenceInterface(
06663         const QString& busName,
06664         const QString& objectPath,
06665         QObject* parent = 0
06666     );
06667 
06676     ConnectionInterfacePresenceInterface(
06677         const QDBusConnection& connection,
06678         const QString& busName,
06679         const QString& objectPath,
06680         QObject* parent = 0
06681     );
06682 
06689     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
06690 
06698     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
06699 
06707     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
06708 
06715     Tp::PendingVariantMap *requestAllProperties() const
06716     {
06717         return internalRequestAllProperties();
06718     }
06719 
06720 public Q_SLOTS:
06742     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters, int timeout = -1)
06743     {
06744         if (!invalidationReason().isEmpty()) {
06745             return QDBusPendingReply<>(QDBusMessage::createError(
06746                 invalidationReason(),
06747                 invalidationMessage()
06748             ));
06749         }
06750 
06751         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06752                 this->staticInterfaceName(), QLatin1String("AddStatus"));
06753         callMessage << QVariant::fromValue(status) << QVariant::fromValue(parameters);
06754         return this->connection().asyncCall(callMessage, timeout);
06755     }
06756 
06770     inline QDBusPendingReply<> ClearStatus(int timeout = -1)
06771     {
06772         if (!invalidationReason().isEmpty()) {
06773             return QDBusPendingReply<>(QDBusMessage::createError(
06774                 invalidationReason(),
06775                 invalidationMessage()
06776             ));
06777         }
06778 
06779         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06780                 this->staticInterfaceName(), QLatin1String("ClearStatus"));
06781         return this->connection().asyncCall(callMessage, timeout);
06782     }
06783 
06807     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts, int timeout = -1)
06808     {
06809         if (!invalidationReason().isEmpty()) {
06810             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
06811                 invalidationReason(),
06812                 invalidationMessage()
06813             ));
06814         }
06815 
06816         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06817                 this->staticInterfaceName(), QLatin1String("GetPresence"));
06818         callMessage << QVariant::fromValue(contacts);
06819         return this->connection().asyncCall(callMessage, timeout);
06820     }
06821 
06843     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses(int timeout = -1)
06844     {
06845         if (!invalidationReason().isEmpty()) {
06846             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
06847                 invalidationReason(),
06848                 invalidationMessage()
06849             ));
06850         }
06851 
06852         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06853                 this->staticInterfaceName(), QLatin1String("GetStatuses"));
06854         return this->connection().asyncCall(callMessage, timeout);
06855     }
06856 
06875     inline QDBusPendingReply<> RemoveStatus(const QString& status, int timeout = -1)
06876     {
06877         if (!invalidationReason().isEmpty()) {
06878             return QDBusPendingReply<>(QDBusMessage::createError(
06879                 invalidationReason(),
06880                 invalidationMessage()
06881             ));
06882         }
06883 
06884         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06885                 this->staticInterfaceName(), QLatin1String("RemoveStatus"));
06886         callMessage << QVariant::fromValue(status);
06887         return this->connection().asyncCall(callMessage, timeout);
06888     }
06889 
06908     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts, int timeout = -1)
06909     {
06910         if (!invalidationReason().isEmpty()) {
06911             return QDBusPendingReply<>(QDBusMessage::createError(
06912                 invalidationReason(),
06913                 invalidationMessage()
06914             ));
06915         }
06916 
06917         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06918                 this->staticInterfaceName(), QLatin1String("RequestPresence"));
06919         callMessage << QVariant::fromValue(contacts);
06920         return this->connection().asyncCall(callMessage, timeout);
06921     }
06922 
06938     inline QDBusPendingReply<> SetLastActivityTime(uint time, int timeout = -1)
06939     {
06940         if (!invalidationReason().isEmpty()) {
06941             return QDBusPendingReply<>(QDBusMessage::createError(
06942                 invalidationReason(),
06943                 invalidationMessage()
06944             ));
06945         }
06946 
06947         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
06948                 this->staticInterfaceName(), QLatin1String("SetLastActivityTime"));
06949         callMessage << QVariant::fromValue(time);
06950         return this->connection().asyncCall(callMessage, timeout);
06951     }
06952 
06990     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses, int timeout = -1)
06991     {
06992         if (!invalidationReason().isEmpty()) {
06993             return QDBusPendingReply<>(QDBusMessage::createError(
06994                 invalidationReason(),
06995                 invalidationMessage()
06996             ));
06997         }
06998 
06999         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07000                 this->staticInterfaceName(), QLatin1String("SetStatus"));
07001         callMessage << QVariant::fromValue(statuses);
07002         return this->connection().asyncCall(callMessage, timeout);
07003     }
07004 
07005 Q_SIGNALS:
07022     void PresenceUpdate(const Tp::ContactPresences& presence);
07023 
07024 protected:
07025     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07026 };
07027 
07035 class TP_QT_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
07036 {
07037     Q_OBJECT
07038 
07039 public:
07046     static inline QLatin1String staticInterfaceName()
07047     {
07048         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.Requests");
07049     }
07050 
07058     ConnectionInterfaceRequestsInterface(
07059         const QString& busName,
07060         const QString& objectPath,
07061         QObject* parent = 0
07062     );
07063 
07072     ConnectionInterfaceRequestsInterface(
07073         const QDBusConnection& connection,
07074         const QString& busName,
07075         const QString& objectPath,
07076         QObject* parent = 0
07077     );
07078 
07085     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
07086 
07094     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
07095 
07103     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07104 
07115     inline Tp::PendingVariant *requestPropertyChannels() const
07116     {
07117         return internalRequestProperty(QLatin1String("Channels"));
07118     }
07119 
07149     inline Tp::PendingVariant *requestPropertyRequestableChannelClasses() const
07150     {
07151         return internalRequestProperty(QLatin1String("RequestableChannelClasses"));
07152     }
07153 
07160     Tp::PendingVariantMap *requestAllProperties() const
07161     {
07162         return internalRequestAllProperties();
07163     }
07164 
07165 public Q_SLOTS:
07247     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request, int timeout = -1)
07248     {
07249         if (!invalidationReason().isEmpty()) {
07250             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
07251                 invalidationReason(),
07252                 invalidationMessage()
07253             ));
07254         }
07255 
07256         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07257                 this->staticInterfaceName(), QLatin1String("CreateChannel"));
07258         callMessage << QVariant::fromValue(request);
07259         return this->connection().asyncCall(callMessage, timeout);
07260     }
07261 
07326     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request, int timeout = -1)
07327     {
07328         if (!invalidationReason().isEmpty()) {
07329             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
07330                 invalidationReason(),
07331                 invalidationMessage()
07332             ));
07333         }
07334 
07335         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07336                 this->staticInterfaceName(), QLatin1String("EnsureChannel"));
07337         callMessage << QVariant::fromValue(request);
07338         return this->connection().asyncCall(callMessage, timeout);
07339     }
07340 
07341 Q_SIGNALS:
07385     void NewChannels(const Tp::ChannelDetailsList& channels);
07386 
07399     void ChannelClosed(const QDBusObjectPath& removed);
07400 
07401 protected:
07402     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07403 };
07404 
07412 class TP_QT_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
07413 {
07414     Q_OBJECT
07415 
07416 public:
07423     static inline QLatin1String staticInterfaceName()
07424     {
07425         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.ServicePoint");
07426     }
07427 
07435     ConnectionInterfaceServicePointInterface(
07436         const QString& busName,
07437         const QString& objectPath,
07438         QObject* parent = 0
07439     );
07440 
07449     ConnectionInterfaceServicePointInterface(
07450         const QDBusConnection& connection,
07451         const QString& busName,
07452         const QString& objectPath,
07453         QObject* parent = 0
07454     );
07455 
07462     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
07463 
07471     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
07472 
07480     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07481 
07493     inline Tp::PendingVariant *requestPropertyKnownServicePoints() const
07494     {
07495         return internalRequestProperty(QLatin1String("KnownServicePoints"));
07496     }
07497 
07504     Tp::PendingVariantMap *requestAllProperties() const
07505     {
07506         return internalRequestAllProperties();
07507     }
07508 
07509 Q_SIGNALS:
07523     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
07524 
07525 protected:
07526     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07527 };
07528 
07536 class TP_QT_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
07537 {
07538     Q_OBJECT
07539 
07540 public:
07547     static inline QLatin1String staticInterfaceName()
07548     {
07549         return QLatin1String("org.freedesktop.Telepathy.Connection.Interface.SimplePresence");
07550     }
07551 
07559     ConnectionInterfaceSimplePresenceInterface(
07560         const QString& busName,
07561         const QString& objectPath,
07562         QObject* parent = 0
07563     );
07564 
07573     ConnectionInterfaceSimplePresenceInterface(
07574         const QDBusConnection& connection,
07575         const QString& busName,
07576         const QString& objectPath,
07577         QObject* parent = 0
07578     );
07579 
07586     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
07587 
07595     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
07596 
07604     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
07605 
07647     inline Tp::PendingVariant *requestPropertyStatuses() const
07648     {
07649         return internalRequestProperty(QLatin1String("Statuses"));
07650     }
07651 
07696     inline Tp::PendingVariant *requestPropertyMaximumStatusMessageLength() const
07697     {
07698         return internalRequestProperty(QLatin1String("MaximumStatusMessageLength"));
07699     }
07700 
07707     Tp::PendingVariantMap *requestAllProperties() const
07708     {
07709         return internalRequestAllProperties();
07710     }
07711 
07712 public Q_SLOTS:
07776     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage, int timeout = -1)
07777     {
07778         if (!invalidationReason().isEmpty()) {
07779             return QDBusPendingReply<>(QDBusMessage::createError(
07780                 invalidationReason(),
07781                 invalidationMessage()
07782             ));
07783         }
07784 
07785         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07786                 this->staticInterfaceName(), QLatin1String("SetPresence"));
07787         callMessage << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
07788         return this->connection().asyncCall(callMessage, timeout);
07789     }
07790 
07822     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts, int timeout = -1)
07823     {
07824         if (!invalidationReason().isEmpty()) {
07825             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
07826                 invalidationReason(),
07827                 invalidationMessage()
07828             ));
07829         }
07830 
07831         QDBusMessage callMessage = QDBusMessage::createMethodCall(this->service(), this->path(),
07832                 this->staticInterfaceName(), QLatin1String("GetPresences"));
07833         callMessage << QVariant::fromValue(contacts);
07834         return this->connection().asyncCall(callMessage, timeout);
07835     }
07836 
07837 Q_SIGNALS:
07850     void PresencesChanged(const Tp::SimpleContactPresences& presence);
07851 
07852 protected:
07853     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
07854 };
07855 }
07856 }
07857 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
07858 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAddressingInterface*)
07859 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
07860 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
07861 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
07862 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
07863 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
07864 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
07865 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
07866 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactBlockingInterface*)
07867 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
07868 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
07869 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
07870 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
07871 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
07872 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
07873 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceMailNotificationInterface*)
07874 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
07875 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
07876 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
07877 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
07878 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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