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

cli-connection.h

00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
00003  *
00004  * This file can be distributed under the same terms as the specification from
00005  * which it was generated.
00006  */
00007 
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt4/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025 
00026 // basically the same as GLib's G_GNUC_DEPRECATED
00027 #ifndef TELEPATHY_GNUC_DEPRECATED
00028 #   if defined(Q_CC_GNUC) && __GNUC__ >= 4
00029 #       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
00030 #   else
00031 #       define TELEPATHY_GNUC_DEPRECATED
00032 #   endif
00033 #endif
00034 namespace Tp
00035 {
00036 namespace Client
00037 {
00038 
00046 class TELEPATHY_QT4_EXPORT ConnectionInterface : public Tp::AbstractInterface
00047 {
00048     Q_OBJECT
00049 
00050 public:
00057     static inline const char *staticInterfaceName()
00058     {
00059         return "org.freedesktop.Telepathy.Connection";
00060     }
00061 
00069     ConnectionInterface(
00070         const QString& busName,
00071         const QString& objectPath,
00072         QObject* parent = 0
00073     );
00074 
00083     ConnectionInterface(
00084         const QDBusConnection& connection,
00085         const QString& busName,
00086         const QString& objectPath,
00087         QObject* parent = 0
00088     );
00089 
00096     ConnectionInterface(Tp::DBusProxy *proxy);
00097 
00123     Q_PROPERTY(QStringList Interfaces READ Interfaces)
00124 
00125     
00133     inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
00134     {
00135         return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
00136     }
00137 
00147     Q_PROPERTY(uint SelfHandle READ SelfHandle)
00148 
00149     
00157     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
00158     {
00159         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
00160     }
00161 
00174     Q_PROPERTY(uint Status READ Status)
00175 
00176     
00184     inline uint Status() const TELEPATHY_GNUC_DEPRECATED
00185     {
00186         return qvariant_cast<uint>(internalPropGet("Status"));
00187     }
00188 
00189 public Q_SLOTS:
00200     inline QDBusPendingReply<> Connect()
00201     {
00202         if (!invalidationReason().isEmpty()) {
00203             return QDBusPendingReply<>(QDBusMessage::createError(
00204                 invalidationReason(),
00205                 invalidationMessage()
00206             ));
00207         }
00208 
00209 
00210         return asyncCall(QLatin1String("Connect"));
00211     }
00212 
00220     inline QDBusPendingReply<> Disconnect()
00221     {
00222         if (!invalidationReason().isEmpty()) {
00223             return QDBusPendingReply<>(QDBusMessage::createError(
00224                 invalidationReason(),
00225                 invalidationMessage()
00226             ));
00227         }
00228 
00229 
00230         return asyncCall(QLatin1String("Disconnect"));
00231     }
00232 
00244     inline QDBusPendingReply<QStringList> GetInterfaces()
00245     {
00246         if (!invalidationReason().isEmpty()) {
00247             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00248                 invalidationReason(),
00249                 invalidationMessage()
00250             ));
00251         }
00252 
00253 
00254         return asyncCall(QLatin1String("GetInterfaces"));
00255     }
00256 
00266     inline QDBusPendingReply<QString> GetProtocol()
00267     {
00268         if (!invalidationReason().isEmpty()) {
00269             return QDBusPendingReply<QString>(QDBusMessage::createError(
00270                 invalidationReason(),
00271                 invalidationMessage()
00272             ));
00273         }
00274 
00275 
00276         return asyncCall(QLatin1String("GetProtocol"));
00277     }
00278 
00289     inline QDBusPendingReply<uint> GetSelfHandle()
00290     {
00291         if (!invalidationReason().isEmpty()) {
00292             return QDBusPendingReply<uint>(QDBusMessage::createError(
00293                 invalidationReason(),
00294                 invalidationMessage()
00295             ));
00296         }
00297 
00298 
00299         return asyncCall(QLatin1String("GetSelfHandle"));
00300     }
00301 
00311     inline QDBusPendingReply<uint> GetStatus()
00312     {
00313         if (!invalidationReason().isEmpty()) {
00314             return QDBusPendingReply<uint>(QDBusMessage::createError(
00315                 invalidationReason(),
00316                 invalidationMessage()
00317             ));
00318         }
00319 
00320 
00321         return asyncCall(QLatin1String("GetStatus"));
00322     }
00323 
00353     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles)
00354     {
00355         if (!invalidationReason().isEmpty()) {
00356             return QDBusPendingReply<>(QDBusMessage::createError(
00357                 invalidationReason(),
00358                 invalidationMessage()
00359             ));
00360         }
00361 
00362 
00363         QList<QVariant> argumentList;
00364         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00365         return asyncCallWithArgumentList(QLatin1String("HoldHandles"), argumentList);
00366     }
00367 
00386     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles)
00387     {
00388         if (!invalidationReason().isEmpty()) {
00389             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00390                 invalidationReason(),
00391                 invalidationMessage()
00392             ));
00393         }
00394 
00395 
00396         QList<QVariant> argumentList;
00397         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00398         return asyncCallWithArgumentList(QLatin1String("InspectHandles"), argumentList);
00399     }
00400 
00410     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels()
00411     {
00412         if (!invalidationReason().isEmpty()) {
00413             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00414                 invalidationReason(),
00415                 invalidationMessage()
00416             ));
00417         }
00418 
00419 
00420         return asyncCall(QLatin1String("ListChannels"));
00421     }
00422 
00439     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles)
00440     {
00441         if (!invalidationReason().isEmpty()) {
00442             return QDBusPendingReply<>(QDBusMessage::createError(
00443                 invalidationReason(),
00444                 invalidationMessage()
00445             ));
00446         }
00447 
00448 
00449         QList<QVariant> argumentList;
00450         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00451         return asyncCallWithArgumentList(QLatin1String("ReleaseHandles"), argumentList);
00452     }
00453 
00526     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler)
00527     {
00528         if (!invalidationReason().isEmpty()) {
00529             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00530                 invalidationReason(),
00531                 invalidationMessage()
00532             ));
00533         }
00534 
00535 
00536         QList<QVariant> argumentList;
00537         argumentList << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00538         return asyncCallWithArgumentList(QLatin1String("RequestChannel"), argumentList);
00539     }
00540 
00567     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers)
00568     {
00569         if (!invalidationReason().isEmpty()) {
00570             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00571                 invalidationReason(),
00572                 invalidationMessage()
00573             ));
00574         }
00575 
00576 
00577         QList<QVariant> argumentList;
00578         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00579         return asyncCallWithArgumentList(QLatin1String("RequestHandles"), argumentList);
00580     }
00581 
00582 Q_SIGNALS:
00594     void SelfHandleChanged(uint selfHandle);
00595 
00637     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00638 
00702     void ConnectionError(const QString& error, const QVariantMap& details);
00703 
00720     void StatusChanged(uint status, uint reason);
00721 
00722 protected:
00723     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00724 };
00725 
00733 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00734 {
00735     Q_OBJECT
00736 
00737 public:
00744     static inline const char *staticInterfaceName()
00745     {
00746         return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
00747     }
00748 
00756     ConnectionInterfaceAliasingInterface(
00757         const QString& busName,
00758         const QString& objectPath,
00759         QObject* parent = 0
00760     );
00761 
00770     ConnectionInterfaceAliasingInterface(
00771         const QDBusConnection& connection,
00772         const QString& busName,
00773         const QString& objectPath,
00774         QObject* parent = 0
00775     );
00776 
00783     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
00784 
00792     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
00793 
00801     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00802 
00803 public Q_SLOTS:
00814     inline QDBusPendingReply<uint> GetAliasFlags()
00815     {
00816         if (!invalidationReason().isEmpty()) {
00817             return QDBusPendingReply<uint>(QDBusMessage::createError(
00818                 invalidationReason(),
00819                 invalidationMessage()
00820             ));
00821         }
00822 
00823 
00824         return asyncCall(QLatin1String("GetAliasFlags"));
00825     }
00826 
00840     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
00841     {
00842         if (!invalidationReason().isEmpty()) {
00843             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00844                 invalidationReason(),
00845                 invalidationMessage()
00846             ));
00847         }
00848 
00849 
00850         QList<QVariant> argumentList;
00851         argumentList << QVariant::fromValue(contacts);
00852         return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
00853     }
00854 
00872     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
00873     {
00874         if (!invalidationReason().isEmpty()) {
00875             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
00876                 invalidationReason(),
00877                 invalidationMessage()
00878             ));
00879         }
00880 
00881 
00882         QList<QVariant> argumentList;
00883         argumentList << QVariant::fromValue(contacts);
00884         return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
00885     }
00886 
00901     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
00902     {
00903         if (!invalidationReason().isEmpty()) {
00904             return QDBusPendingReply<>(QDBusMessage::createError(
00905                 invalidationReason(),
00906                 invalidationMessage()
00907             ));
00908         }
00909 
00910 
00911         QList<QVariant> argumentList;
00912         argumentList << QVariant::fromValue(aliases);
00913         return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
00914     }
00915 
00916 Q_SIGNALS:
00931     void AliasesChanged(const Tp::AliasPairList& aliases);
00932 
00933 protected:
00934     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00935 };
00936 
00944 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
00945 {
00946     Q_OBJECT
00947 
00948 public:
00955     static inline const char *staticInterfaceName()
00956     {
00957         return "org.freedesktop.Telepathy.Connection.Interface.Anonymity";
00958     }
00959 
00967     ConnectionInterfaceAnonymityInterface(
00968         const QString& busName,
00969         const QString& objectPath,
00970         QObject* parent = 0
00971     );
00972 
00981     ConnectionInterfaceAnonymityInterface(
00982         const QDBusConnection& connection,
00983         const QString& busName,
00984         const QString& objectPath,
00985         QObject* parent = 0
00986     );
00987 
00994     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00995 
01003     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01004 
01012     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01013 
01020     Q_PROPERTY(uint SupportedAnonymityModes READ SupportedAnonymityModes)
01021 
01022     
01030     inline uint SupportedAnonymityModes() const TELEPATHY_GNUC_DEPRECATED
01031     {
01032         return qvariant_cast<uint>(internalPropGet("SupportedAnonymityModes"));
01033     }
01034 
01050     Q_PROPERTY(bool AnonymityMandatory READ AnonymityMandatory WRITE setAnonymityMandatory)
01051 
01052     
01060     inline bool AnonymityMandatory() const TELEPATHY_GNUC_DEPRECATED
01061     {
01062         return qvariant_cast<bool>(internalPropGet("AnonymityMandatory"));
01063     }
01064 
01072     inline void setAnonymityMandatory(bool newValue) TELEPATHY_GNUC_DEPRECATED
01073     {
01074         internalPropSet("AnonymityMandatory", QVariant::fromValue(newValue));
01075     }
01076 
01090     Q_PROPERTY(uint AnonymityModes READ AnonymityModes WRITE setAnonymityModes)
01091 
01092     
01100     inline uint AnonymityModes() const TELEPATHY_GNUC_DEPRECATED
01101     {
01102         return qvariant_cast<uint>(internalPropGet("AnonymityModes"));
01103     }
01104 
01112     inline void setAnonymityModes(uint newValue) TELEPATHY_GNUC_DEPRECATED
01113     {
01114         internalPropSet("AnonymityModes", QVariant::fromValue(newValue));
01115     }
01116 
01117 Q_SIGNALS:
01127     void AnonymityModesChanged(uint modes);
01128 
01129 protected:
01130     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01131 };
01132 
01140 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01141 {
01142     Q_OBJECT
01143 
01144 public:
01151     static inline const char *staticInterfaceName()
01152     {
01153         return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
01154     }
01155 
01163     ConnectionInterfaceAvatarsInterface(
01164         const QString& busName,
01165         const QString& objectPath,
01166         QObject* parent = 0
01167     );
01168 
01177     ConnectionInterfaceAvatarsInterface(
01178         const QDBusConnection& connection,
01179         const QString& busName,
01180         const QString& objectPath,
01181         QObject* parent = 0
01182     );
01183 
01190     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01191 
01199     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01200 
01208     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01209 
01217     Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
01218 
01219     
01227     inline QStringList SupportedAvatarMIMETypes() const TELEPATHY_GNUC_DEPRECATED
01228     {
01229         return qvariant_cast<QStringList>(internalPropGet("SupportedAvatarMIMETypes"));
01230     }
01231 
01239     Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
01240 
01241     
01249     inline uint MinimumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01250     {
01251         return qvariant_cast<uint>(internalPropGet("MinimumAvatarHeight"));
01252     }
01253 
01261     Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
01262 
01263     
01271     inline uint MinimumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01272     {
01273         return qvariant_cast<uint>(internalPropGet("MinimumAvatarWidth"));
01274     }
01275 
01286     Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
01287 
01288     
01296     inline uint RecommendedAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01297     {
01298         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarHeight"));
01299     }
01300 
01309     Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
01310 
01311     
01319     inline uint RecommendedAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01320     {
01321         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarWidth"));
01322     }
01323 
01331     Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
01332 
01333     
01341     inline uint MaximumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01342     {
01343         return qvariant_cast<uint>(internalPropGet("MaximumAvatarHeight"));
01344     }
01345 
01353     Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
01354 
01355     
01363     inline uint MaximumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01364     {
01365         return qvariant_cast<uint>(internalPropGet("MaximumAvatarWidth"));
01366     }
01367 
01375     Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
01376 
01377     
01385     inline uint MaximumAvatarBytes() const TELEPATHY_GNUC_DEPRECATED
01386     {
01387         return qvariant_cast<uint>(internalPropGet("MaximumAvatarBytes"));
01388     }
01389 
01390 public Q_SLOTS:
01420     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
01421     {
01422         if (!invalidationReason().isEmpty()) {
01423             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01424                 invalidationReason(),
01425                 invalidationMessage()
01426             ));
01427         }
01428 
01429 
01430         return asyncCall(QLatin1String("GetAvatarRequirements"));
01431     }
01432 
01449     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
01450     {
01451         if (!invalidationReason().isEmpty()) {
01452             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01453                 invalidationReason(),
01454                 invalidationMessage()
01455             ));
01456         }
01457 
01458 
01459         QList<QVariant> argumentList;
01460         argumentList << QVariant::fromValue(contacts);
01461         return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
01462     }
01463 
01486     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
01487     {
01488         if (!invalidationReason().isEmpty()) {
01489             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01490                 invalidationReason(),
01491                 invalidationMessage()
01492             ));
01493         }
01494 
01495 
01496         QList<QVariant> argumentList;
01497         argumentList << QVariant::fromValue(contacts);
01498         return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
01499     }
01500 
01520     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
01521     {
01522         if (!invalidationReason().isEmpty()) {
01523             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01524                 invalidationReason(),
01525                 invalidationMessage()
01526             ));
01527         }
01528 
01529 
01530         QList<QVariant> argumentList;
01531         argumentList << QVariant::fromValue(contact);
01532         return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
01533     }
01534 
01548     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
01549     {
01550         if (!invalidationReason().isEmpty()) {
01551             return QDBusPendingReply<>(QDBusMessage::createError(
01552                 invalidationReason(),
01553                 invalidationMessage()
01554             ));
01555         }
01556 
01557 
01558         QList<QVariant> argumentList;
01559         argumentList << QVariant::fromValue(contacts);
01560         return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
01561     }
01562 
01581     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
01582     {
01583         if (!invalidationReason().isEmpty()) {
01584             return QDBusPendingReply<QString>(QDBusMessage::createError(
01585                 invalidationReason(),
01586                 invalidationMessage()
01587             ));
01588         }
01589 
01590 
01591         QList<QVariant> argumentList;
01592         argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01593         return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
01594     }
01595 
01601     inline QDBusPendingReply<> ClearAvatar()
01602     {
01603         if (!invalidationReason().isEmpty()) {
01604             return QDBusPendingReply<>(QDBusMessage::createError(
01605                 invalidationReason(),
01606                 invalidationMessage()
01607             ));
01608         }
01609 
01610 
01611         return asyncCall(QLatin1String("ClearAvatar"));
01612     }
01613 
01614 Q_SIGNALS:
01631     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01632 
01655     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01656 
01657 protected:
01658     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01659 };
01660 
01668 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01669 {
01670     Q_OBJECT
01671 
01672 public:
01679     static inline const char *staticInterfaceName()
01680     {
01681         return "org.freedesktop.Telepathy.Connection.Interface.Balance";
01682     }
01683 
01691     ConnectionInterfaceBalanceInterface(
01692         const QString& busName,
01693         const QString& objectPath,
01694         QObject* parent = 0
01695     );
01696 
01705     ConnectionInterfaceBalanceInterface(
01706         const QDBusConnection& connection,
01707         const QString& busName,
01708         const QString& objectPath,
01709         QObject* parent = 0
01710     );
01711 
01718     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01719 
01727     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01728 
01736     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01737 
01749     Q_PROPERTY(Tp::CurrencyAmount AccountBalance READ AccountBalance)
01750 
01751     
01759     inline Tp::CurrencyAmount AccountBalance() const TELEPATHY_GNUC_DEPRECATED
01760     {
01761         return qvariant_cast<Tp::CurrencyAmount>(internalPropGet("AccountBalance"));
01762     }
01763 
01764 Q_SIGNALS:
01775     void BalanceChanged(const Tp::CurrencyAmount& balance);
01776 
01777 protected:
01778     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01779 };
01780 
01788 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
01789 {
01790     Q_OBJECT
01791 
01792 public:
01799     static inline const char *staticInterfaceName()
01800     {
01801         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
01802     }
01803 
01811     ConnectionInterfaceCapabilitiesInterface(
01812         const QString& busName,
01813         const QString& objectPath,
01814         QObject* parent = 0
01815     );
01816 
01825     ConnectionInterfaceCapabilitiesInterface(
01826         const QDBusConnection& connection,
01827         const QString& busName,
01828         const QString& objectPath,
01829         QObject* parent = 0
01830     );
01831 
01838     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
01839 
01847     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01848 
01856     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01857 
01858 public Q_SLOTS:
01903     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
01904     {
01905         if (!invalidationReason().isEmpty()) {
01906             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
01907                 invalidationReason(),
01908                 invalidationMessage()
01909             ));
01910         }
01911 
01912 
01913         QList<QVariant> argumentList;
01914         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
01915         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
01916     }
01917 
01943     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
01944     {
01945         if (!invalidationReason().isEmpty()) {
01946             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
01947                 invalidationReason(),
01948                 invalidationMessage()
01949             ));
01950         }
01951 
01952 
01953         QList<QVariant> argumentList;
01954         argumentList << QVariant::fromValue(handles);
01955         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
01956     }
01957 
01958 Q_SIGNALS:
01981     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
01982 
01983 protected:
01984     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01985 };
01986 
01994 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
01995 {
01996     Q_OBJECT
01997 
01998 public:
02005     static inline const char *staticInterfaceName()
02006     {
02007         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
02008     }
02009 
02017     ConnectionInterfaceContactCapabilitiesInterface(
02018         const QString& busName,
02019         const QString& objectPath,
02020         QObject* parent = 0
02021     );
02022 
02031     ConnectionInterfaceContactCapabilitiesInterface(
02032         const QDBusConnection& connection,
02033         const QString& busName,
02034         const QString& objectPath,
02035         QObject* parent = 0
02036     );
02037 
02044     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
02045 
02053     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02054 
02062     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02063 
02064 public Q_SLOTS:
02120     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
02121     {
02122         if (!invalidationReason().isEmpty()) {
02123             return QDBusPendingReply<>(QDBusMessage::createError(
02124                 invalidationReason(),
02125                 invalidationMessage()
02126             ));
02127         }
02128 
02129 
02130         QList<QVariant> argumentList;
02131         argumentList << QVariant::fromValue(handlerCapabilities);
02132         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
02133     }
02134 
02159     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
02160     {
02161         if (!invalidationReason().isEmpty()) {
02162             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
02163                 invalidationReason(),
02164                 invalidationMessage()
02165             ));
02166         }
02167 
02168 
02169         QList<QVariant> argumentList;
02170         argumentList << QVariant::fromValue(handles);
02171         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
02172     }
02173 
02174 Q_SIGNALS:
02191     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
02192 
02193 protected:
02194     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02195 };
02196 
02204 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
02205 {
02206     Q_OBJECT
02207 
02208 public:
02215     static inline const char *staticInterfaceName()
02216     {
02217         return "org.freedesktop.Telepathy.Connection.Interface.ContactInfo";
02218     }
02219 
02227     ConnectionInterfaceContactInfoInterface(
02228         const QString& busName,
02229         const QString& objectPath,
02230         QObject* parent = 0
02231     );
02232 
02241     ConnectionInterfaceContactInfoInterface(
02242         const QDBusConnection& connection,
02243         const QString& busName,
02244         const QString& objectPath,
02245         QObject* parent = 0
02246     );
02247 
02254     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
02255 
02263     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
02264 
02272     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02273 
02291     Q_PROPERTY(uint ContactInfoFlags READ ContactInfoFlags)
02292 
02293     
02301     inline uint ContactInfoFlags() const TELEPATHY_GNUC_DEPRECATED
02302     {
02303         return qvariant_cast<uint>(internalPropGet("ContactInfoFlags"));
02304     }
02305 
02357     Q_PROPERTY(Tp::FieldSpecs SupportedFields READ SupportedFields)
02358 
02359     
02367     inline Tp::FieldSpecs SupportedFields() const TELEPATHY_GNUC_DEPRECATED
02368     {
02369         return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
02370     }
02371 
02372 public Q_SLOTS:
02390     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
02391     {
02392         if (!invalidationReason().isEmpty()) {
02393             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
02394                 invalidationReason(),
02395                 invalidationMessage()
02396             ));
02397         }
02398 
02399 
02400         QList<QVariant> argumentList;
02401         argumentList << QVariant::fromValue(contacts);
02402         return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
02403     }
02404 
02419     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
02420     {
02421         if (!invalidationReason().isEmpty()) {
02422             return QDBusPendingReply<>(QDBusMessage::createError(
02423                 invalidationReason(),
02424                 invalidationMessage()
02425             ));
02426         }
02427 
02428 
02429         QList<QVariant> argumentList;
02430         argumentList << QVariant::fromValue(contacts);
02431         return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
02432     }
02433 
02450     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
02451     {
02452         if (!invalidationReason().isEmpty()) {
02453             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
02454                 invalidationReason(),
02455                 invalidationMessage()
02456             ));
02457         }
02458 
02459 
02460         QList<QVariant> argumentList;
02461         argumentList << QVariant::fromValue(contact);
02462         return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
02463     }
02464 
02477     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
02478     {
02479         if (!invalidationReason().isEmpty()) {
02480             return QDBusPendingReply<>(QDBusMessage::createError(
02481                 invalidationReason(),
02482                 invalidationMessage()
02483             ));
02484         }
02485 
02486 
02487         QList<QVariant> argumentList;
02488         argumentList << QVariant::fromValue(contactInfo);
02489         return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
02490     }
02491 
02492 Q_SIGNALS:
02507     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
02508 
02509 protected:
02510     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02511 };
02512 
02520 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
02521 {
02522     Q_OBJECT
02523 
02524 public:
02531     static inline const char *staticInterfaceName()
02532     {
02533         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
02534     }
02535 
02543     ConnectionInterfaceContactsInterface(
02544         const QString& busName,
02545         const QString& objectPath,
02546         QObject* parent = 0
02547     );
02548 
02557     ConnectionInterfaceContactsInterface(
02558         const QDBusConnection& connection,
02559         const QString& busName,
02560         const QString& objectPath,
02561         QObject* parent = 0
02562     );
02563 
02570     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
02571 
02579     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02580 
02588     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02589 
02596     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
02597 
02598     
02606     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
02607     {
02608         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
02609     }
02610 
02611 public Q_SLOTS:
02677     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
02678     {
02679         if (!invalidationReason().isEmpty()) {
02680             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
02681                 invalidationReason(),
02682                 invalidationMessage()
02683             ));
02684         }
02685 
02686 
02687         QList<QVariant> argumentList;
02688         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
02689         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
02690     }
02691 
02692 protected:
02693     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02694 };
02695 
02703 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
02704 {
02705     Q_OBJECT
02706 
02707 public:
02714     static inline const char *staticInterfaceName()
02715     {
02716         return "org.freedesktop.Telepathy.Connection.Interface.Location";
02717     }
02718 
02726     ConnectionInterfaceLocationInterface(
02727         const QString& busName,
02728         const QString& objectPath,
02729         QObject* parent = 0
02730     );
02731 
02740     ConnectionInterfaceLocationInterface(
02741         const QDBusConnection& connection,
02742         const QString& busName,
02743         const QString& objectPath,
02744         QObject* parent = 0
02745     );
02746 
02753     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
02754 
02762     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
02763 
02771     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02772 
02778     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
02779 
02780     
02788     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
02789     {
02790         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
02791     }
02792 
02801     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
02802 
02803     
02811     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
02812     {
02813         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
02814     }
02815 
02823     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
02824     {
02825         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
02826     }
02827 
02835     Q_PROPERTY(uint SupportedLocationFeatures READ SupportedLocationFeatures)
02836 
02837     
02845     inline uint SupportedLocationFeatures() const TELEPATHY_GNUC_DEPRECATED
02846     {
02847         return qvariant_cast<uint>(internalPropGet("SupportedLocationFeatures"));
02848     }
02849 
02850 public Q_SLOTS:
02874     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
02875     {
02876         if (!invalidationReason().isEmpty()) {
02877             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
02878                 invalidationReason(),
02879                 invalidationMessage()
02880             ));
02881         }
02882 
02883 
02884         QList<QVariant> argumentList;
02885         argumentList << QVariant::fromValue(contacts);
02886         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
02887     }
02888 
02908     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
02909     {
02910         if (!invalidationReason().isEmpty()) {
02911             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
02912                 invalidationReason(),
02913                 invalidationMessage()
02914             ));
02915         }
02916 
02917 
02918         QList<QVariant> argumentList;
02919         argumentList << QVariant::fromValue(contact);
02920         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
02921     }
02922 
02939     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
02940     {
02941         if (!invalidationReason().isEmpty()) {
02942             return QDBusPendingReply<>(QDBusMessage::createError(
02943                 invalidationReason(),
02944                 invalidationMessage()
02945             ));
02946         }
02947 
02948 
02949         QList<QVariant> argumentList;
02950         argumentList << QVariant::fromValue(location);
02951         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
02952     }
02953 
02954 Q_SIGNALS:
02969     void LocationUpdated(uint contact, const QVariantMap& location);
02970 
02971 protected:
02972     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02973 };
02974 
02982 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
02983 {
02984     Q_OBJECT
02985 
02986 public:
02993     static inline const char *staticInterfaceName()
02994     {
02995         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
02996     }
02997 
03005     ConnectionInterfacePresenceInterface(
03006         const QString& busName,
03007         const QString& objectPath,
03008         QObject* parent = 0
03009     );
03010 
03019     ConnectionInterfacePresenceInterface(
03020         const QDBusConnection& connection,
03021         const QString& busName,
03022         const QString& objectPath,
03023         QObject* parent = 0
03024     );
03025 
03032     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
03033 
03041     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
03042 
03050     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03051 
03052 public Q_SLOTS:
03069     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
03070     {
03071         if (!invalidationReason().isEmpty()) {
03072             return QDBusPendingReply<>(QDBusMessage::createError(
03073                 invalidationReason(),
03074                 invalidationMessage()
03075             ));
03076         }
03077 
03078 
03079         QList<QVariant> argumentList;
03080         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
03081         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
03082     }
03083 
03092     inline QDBusPendingReply<> ClearStatus()
03093     {
03094         if (!invalidationReason().isEmpty()) {
03095             return QDBusPendingReply<>(QDBusMessage::createError(
03096                 invalidationReason(),
03097                 invalidationMessage()
03098             ));
03099         }
03100 
03101 
03102         return asyncCall(QLatin1String("ClearStatus"));
03103     }
03104 
03123     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
03124     {
03125         if (!invalidationReason().isEmpty()) {
03126             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
03127                 invalidationReason(),
03128                 invalidationMessage()
03129             ));
03130         }
03131 
03132 
03133         QList<QVariant> argumentList;
03134         argumentList << QVariant::fromValue(contacts);
03135         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
03136     }
03137 
03154     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
03155     {
03156         if (!invalidationReason().isEmpty()) {
03157             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
03158                 invalidationReason(),
03159                 invalidationMessage()
03160             ));
03161         }
03162 
03163 
03164         return asyncCall(QLatin1String("GetStatuses"));
03165     }
03166 
03180     inline QDBusPendingReply<> RemoveStatus(const QString& status)
03181     {
03182         if (!invalidationReason().isEmpty()) {
03183             return QDBusPendingReply<>(QDBusMessage::createError(
03184                 invalidationReason(),
03185                 invalidationMessage()
03186             ));
03187         }
03188 
03189 
03190         QList<QVariant> argumentList;
03191         argumentList << QVariant::fromValue(status);
03192         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
03193     }
03194 
03208     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
03209     {
03210         if (!invalidationReason().isEmpty()) {
03211             return QDBusPendingReply<>(QDBusMessage::createError(
03212                 invalidationReason(),
03213                 invalidationMessage()
03214             ));
03215         }
03216 
03217 
03218         QList<QVariant> argumentList;
03219         argumentList << QVariant::fromValue(contacts);
03220         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
03221     }
03222 
03233     inline QDBusPendingReply<> SetLastActivityTime(uint time)
03234     {
03235         if (!invalidationReason().isEmpty()) {
03236             return QDBusPendingReply<>(QDBusMessage::createError(
03237                 invalidationReason(),
03238                 invalidationMessage()
03239             ));
03240         }
03241 
03242 
03243         QList<QVariant> argumentList;
03244         argumentList << QVariant::fromValue(time);
03245         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
03246     }
03247 
03278     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
03279     {
03280         if (!invalidationReason().isEmpty()) {
03281             return QDBusPendingReply<>(QDBusMessage::createError(
03282                 invalidationReason(),
03283                 invalidationMessage()
03284             ));
03285         }
03286 
03287 
03288         QList<QVariant> argumentList;
03289         argumentList << QVariant::fromValue(statuses);
03290         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
03291     }
03292 
03293 Q_SIGNALS:
03310     void PresenceUpdate(const Tp::ContactPresences& presence);
03311 
03312 protected:
03313     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03314 };
03315 
03323 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
03324 {
03325     Q_OBJECT
03326 
03327 public:
03334     static inline const char *staticInterfaceName()
03335     {
03336         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
03337     }
03338 
03346     ConnectionInterfaceRequestsInterface(
03347         const QString& busName,
03348         const QString& objectPath,
03349         QObject* parent = 0
03350     );
03351 
03360     ConnectionInterfaceRequestsInterface(
03361         const QDBusConnection& connection,
03362         const QString& busName,
03363         const QString& objectPath,
03364         QObject* parent = 0
03365     );
03366 
03373     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
03374 
03382     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03383 
03391     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03392 
03399     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
03400 
03401     
03409     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
03410     {
03411         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
03412     }
03413 
03437     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
03438 
03439     
03447     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
03448     {
03449         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
03450     }
03451 
03452 public Q_SLOTS:
03521     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
03522     {
03523         if (!invalidationReason().isEmpty()) {
03524             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03525                 invalidationReason(),
03526                 invalidationMessage()
03527             ));
03528         }
03529 
03530 
03531         QList<QVariant> argumentList;
03532         argumentList << QVariant::fromValue(request);
03533         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
03534     }
03535 
03587     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
03588     {
03589         if (!invalidationReason().isEmpty()) {
03590             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03591                 invalidationReason(),
03592                 invalidationMessage()
03593             ));
03594         }
03595 
03596 
03597         QList<QVariant> argumentList;
03598         argumentList << QVariant::fromValue(request);
03599         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
03600     }
03601 
03602 Q_SIGNALS:
03644     void NewChannels(const Tp::ChannelDetailsList& channels);
03645 
03658     void ChannelClosed(const QDBusObjectPath& removed);
03659 
03660 protected:
03661     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03662 };
03663 
03671 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
03672 {
03673     Q_OBJECT
03674 
03675 public:
03682     static inline const char *staticInterfaceName()
03683     {
03684         return "org.freedesktop.Telepathy.Connection.Interface.ServicePoint";
03685     }
03686 
03694     ConnectionInterfaceServicePointInterface(
03695         const QString& busName,
03696         const QString& objectPath,
03697         QObject* parent = 0
03698     );
03699 
03708     ConnectionInterfaceServicePointInterface(
03709         const QDBusConnection& connection,
03710         const QString& busName,
03711         const QString& objectPath,
03712         QObject* parent = 0
03713     );
03714 
03721     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
03722 
03730     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
03731 
03739     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03740 
03746     Q_PROPERTY(Tp::ServicePointInfoList KnownServicePoints READ KnownServicePoints)
03747 
03748     
03756     inline Tp::ServicePointInfoList KnownServicePoints() const TELEPATHY_GNUC_DEPRECATED
03757     {
03758         return qvariant_cast<Tp::ServicePointInfoList>(internalPropGet("KnownServicePoints"));
03759     }
03760 
03761 Q_SIGNALS:
03773     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
03774 
03775 protected:
03776     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03777 };
03778 
03786 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
03787 {
03788     Q_OBJECT
03789 
03790 public:
03797     static inline const char *staticInterfaceName()
03798     {
03799         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
03800     }
03801 
03809     ConnectionInterfaceSimplePresenceInterface(
03810         const QString& busName,
03811         const QString& objectPath,
03812         QObject* parent = 0
03813     );
03814 
03823     ConnectionInterfaceSimplePresenceInterface(
03824         const QDBusConnection& connection,
03825         const QString& busName,
03826         const QString& objectPath,
03827         QObject* parent = 0
03828     );
03829 
03836     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
03837 
03845     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
03846 
03854     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03855 
03891     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
03892 
03893     
03901     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
03902     {
03903         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
03904     }
03905 
03906 public Q_SLOTS:
03961     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
03962     {
03963         if (!invalidationReason().isEmpty()) {
03964             return QDBusPendingReply<>(QDBusMessage::createError(
03965                 invalidationReason(),
03966                 invalidationMessage()
03967             ));
03968         }
03969 
03970 
03971         QList<QVariant> argumentList;
03972         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
03973         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
03974     }
03975 
04000     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
04001     {
04002         if (!invalidationReason().isEmpty()) {
04003             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
04004                 invalidationReason(),
04005                 invalidationMessage()
04006             ));
04007         }
04008 
04009 
04010         QList<QVariant> argumentList;
04011         argumentList << QVariant::fromValue(contacts);
04012         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
04013     }
04014 
04015 Q_SIGNALS:
04028     void PresencesChanged(const Tp::SimpleContactPresences& presence);
04029 
04030 protected:
04031     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04032 };
04033 }
04034 }
04035 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
04036 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
04037 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
04038 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
04039 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
04040 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
04041 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
04042 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
04043 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
04044 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
04045 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
04046 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
04047 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
04048 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


Copyright © 2008-2010 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.3.5