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 ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
01995 {
01996     Q_OBJECT
01997 
01998 public:
02005     static inline const char *staticInterfaceName()
02006     {
02007         return "org.freedesktop.Telepathy.Connection.Interface.Cellular";
02008     }
02009 
02017     ConnectionInterfaceCellularInterface(
02018         const QString& busName,
02019         const QString& objectPath,
02020         QObject* parent = 0
02021     );
02022 
02031     ConnectionInterfaceCellularInterface(
02032         const QDBusConnection& connection,
02033         const QString& busName,
02034         const QString& objectPath,
02035         QObject* parent = 0
02036     );
02037 
02044     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02045 
02053     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02054 
02062     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02063 
02086     Q_PROPERTY(uint MessageValidityPeriod READ MessageValidityPeriod WRITE setMessageValidityPeriod)
02087 
02088     
02096     inline uint MessageValidityPeriod() const TELEPATHY_GNUC_DEPRECATED
02097     {
02098         return qvariant_cast<uint>(internalPropGet("MessageValidityPeriod"));
02099     }
02100 
02108     inline void setMessageValidityPeriod(uint newValue) TELEPATHY_GNUC_DEPRECATED
02109     {
02110         internalPropSet("MessageValidityPeriod", QVariant::fromValue(newValue));
02111     }
02112 
02130     Q_PROPERTY(QString MessageServiceCentre READ MessageServiceCentre WRITE setMessageServiceCentre)
02131 
02132     
02140     inline QString MessageServiceCentre() const TELEPATHY_GNUC_DEPRECATED
02141     {
02142         return qvariant_cast<QString>(internalPropGet("MessageServiceCentre"));
02143     }
02144 
02152     inline void setMessageServiceCentre(const QString& newValue) TELEPATHY_GNUC_DEPRECATED
02153     {
02154         internalPropSet("MessageServiceCentre", QVariant::fromValue(newValue));
02155     }
02156 
02164     Q_PROPERTY(QString IMSI READ IMSI)
02165 
02166     
02174     inline QString IMSI() const TELEPATHY_GNUC_DEPRECATED
02175     {
02176         return qvariant_cast<QString>(internalPropGet("IMSI"));
02177     }
02178 
02200     Q_PROPERTY(bool MessageReducedCharacterSet READ MessageReducedCharacterSet WRITE setMessageReducedCharacterSet)
02201 
02202     
02210     inline bool MessageReducedCharacterSet() const TELEPATHY_GNUC_DEPRECATED
02211     {
02212         return qvariant_cast<bool>(internalPropGet("MessageReducedCharacterSet"));
02213     }
02214 
02222     inline void setMessageReducedCharacterSet(bool newValue) TELEPATHY_GNUC_DEPRECATED
02223     {
02224         internalPropSet("MessageReducedCharacterSet", QVariant::fromValue(newValue));
02225     }
02226 
02227 Q_SIGNALS:
02243     void IMSIChanged(const QString& IMSI);
02244 
02245 protected:
02246     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02247 };
02248 
02256 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
02257 {
02258     Q_OBJECT
02259 
02260 public:
02267     static inline const char *staticInterfaceName()
02268     {
02269         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
02270     }
02271 
02279     ConnectionInterfaceContactCapabilitiesInterface(
02280         const QString& busName,
02281         const QString& objectPath,
02282         QObject* parent = 0
02283     );
02284 
02293     ConnectionInterfaceContactCapabilitiesInterface(
02294         const QDBusConnection& connection,
02295         const QString& busName,
02296         const QString& objectPath,
02297         QObject* parent = 0
02298     );
02299 
02306     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
02307 
02315     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02316 
02324     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02325 
02326 public Q_SLOTS:
02382     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
02383     {
02384         if (!invalidationReason().isEmpty()) {
02385             return QDBusPendingReply<>(QDBusMessage::createError(
02386                 invalidationReason(),
02387                 invalidationMessage()
02388             ));
02389         }
02390 
02391 
02392         QList<QVariant> argumentList;
02393         argumentList << QVariant::fromValue(handlerCapabilities);
02394         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
02395     }
02396 
02421     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
02422     {
02423         if (!invalidationReason().isEmpty()) {
02424             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
02425                 invalidationReason(),
02426                 invalidationMessage()
02427             ));
02428         }
02429 
02430 
02431         QList<QVariant> argumentList;
02432         argumentList << QVariant::fromValue(handles);
02433         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
02434     }
02435 
02436 Q_SIGNALS:
02453     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
02454 
02455 protected:
02456     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02457 };
02458 
02466 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
02467 {
02468     Q_OBJECT
02469 
02470 public:
02477     static inline const char *staticInterfaceName()
02478     {
02479         return "org.freedesktop.Telepathy.Connection.Interface.ContactInfo";
02480     }
02481 
02489     ConnectionInterfaceContactInfoInterface(
02490         const QString& busName,
02491         const QString& objectPath,
02492         QObject* parent = 0
02493     );
02494 
02503     ConnectionInterfaceContactInfoInterface(
02504         const QDBusConnection& connection,
02505         const QString& busName,
02506         const QString& objectPath,
02507         QObject* parent = 0
02508     );
02509 
02516     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
02517 
02525     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
02526 
02534     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02535 
02553     Q_PROPERTY(uint ContactInfoFlags READ ContactInfoFlags)
02554 
02555     
02563     inline uint ContactInfoFlags() const TELEPATHY_GNUC_DEPRECATED
02564     {
02565         return qvariant_cast<uint>(internalPropGet("ContactInfoFlags"));
02566     }
02567 
02619     Q_PROPERTY(Tp::FieldSpecs SupportedFields READ SupportedFields)
02620 
02621     
02629     inline Tp::FieldSpecs SupportedFields() const TELEPATHY_GNUC_DEPRECATED
02630     {
02631         return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
02632     }
02633 
02634 public Q_SLOTS:
02652     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
02653     {
02654         if (!invalidationReason().isEmpty()) {
02655             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
02656                 invalidationReason(),
02657                 invalidationMessage()
02658             ));
02659         }
02660 
02661 
02662         QList<QVariant> argumentList;
02663         argumentList << QVariant::fromValue(contacts);
02664         return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
02665     }
02666 
02681     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
02682     {
02683         if (!invalidationReason().isEmpty()) {
02684             return QDBusPendingReply<>(QDBusMessage::createError(
02685                 invalidationReason(),
02686                 invalidationMessage()
02687             ));
02688         }
02689 
02690 
02691         QList<QVariant> argumentList;
02692         argumentList << QVariant::fromValue(contacts);
02693         return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
02694     }
02695 
02712     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
02713     {
02714         if (!invalidationReason().isEmpty()) {
02715             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
02716                 invalidationReason(),
02717                 invalidationMessage()
02718             ));
02719         }
02720 
02721 
02722         QList<QVariant> argumentList;
02723         argumentList << QVariant::fromValue(contact);
02724         return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
02725     }
02726 
02739     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
02740     {
02741         if (!invalidationReason().isEmpty()) {
02742             return QDBusPendingReply<>(QDBusMessage::createError(
02743                 invalidationReason(),
02744                 invalidationMessage()
02745             ));
02746         }
02747 
02748 
02749         QList<QVariant> argumentList;
02750         argumentList << QVariant::fromValue(contactInfo);
02751         return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
02752     }
02753 
02754 Q_SIGNALS:
02769     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
02770 
02771 protected:
02772     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02773 };
02774 
02782 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
02783 {
02784     Q_OBJECT
02785 
02786 public:
02793     static inline const char *staticInterfaceName()
02794     {
02795         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
02796     }
02797 
02805     ConnectionInterfaceContactsInterface(
02806         const QString& busName,
02807         const QString& objectPath,
02808         QObject* parent = 0
02809     );
02810 
02819     ConnectionInterfaceContactsInterface(
02820         const QDBusConnection& connection,
02821         const QString& busName,
02822         const QString& objectPath,
02823         QObject* parent = 0
02824     );
02825 
02832     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
02833 
02841     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02842 
02850     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02851 
02858     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
02859 
02860     
02868     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
02869     {
02870         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
02871     }
02872 
02873 public Q_SLOTS:
02939     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
02940     {
02941         if (!invalidationReason().isEmpty()) {
02942             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
02943                 invalidationReason(),
02944                 invalidationMessage()
02945             ));
02946         }
02947 
02948 
02949         QList<QVariant> argumentList;
02950         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
02951         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
02952     }
02953 
02954 protected:
02955     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02956 };
02957 
02965 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
02966 {
02967     Q_OBJECT
02968 
02969 public:
02976     static inline const char *staticInterfaceName()
02977     {
02978         return "org.freedesktop.Telepathy.Connection.Interface.Location";
02979     }
02980 
02988     ConnectionInterfaceLocationInterface(
02989         const QString& busName,
02990         const QString& objectPath,
02991         QObject* parent = 0
02992     );
02993 
03002     ConnectionInterfaceLocationInterface(
03003         const QDBusConnection& connection,
03004         const QString& busName,
03005         const QString& objectPath,
03006         QObject* parent = 0
03007     );
03008 
03015     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
03016 
03024     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
03025 
03033     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03034 
03040     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
03041 
03042     
03050     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
03051     {
03052         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
03053     }
03054 
03063     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
03064 
03065     
03073     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
03074     {
03075         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
03076     }
03077 
03085     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
03086     {
03087         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
03088     }
03089 
03097     Q_PROPERTY(uint SupportedLocationFeatures READ SupportedLocationFeatures)
03098 
03099     
03107     inline uint SupportedLocationFeatures() const TELEPATHY_GNUC_DEPRECATED
03108     {
03109         return qvariant_cast<uint>(internalPropGet("SupportedLocationFeatures"));
03110     }
03111 
03112 public Q_SLOTS:
03136     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
03137     {
03138         if (!invalidationReason().isEmpty()) {
03139             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
03140                 invalidationReason(),
03141                 invalidationMessage()
03142             ));
03143         }
03144 
03145 
03146         QList<QVariant> argumentList;
03147         argumentList << QVariant::fromValue(contacts);
03148         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
03149     }
03150 
03170     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
03171     {
03172         if (!invalidationReason().isEmpty()) {
03173             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
03174                 invalidationReason(),
03175                 invalidationMessage()
03176             ));
03177         }
03178 
03179 
03180         QList<QVariant> argumentList;
03181         argumentList << QVariant::fromValue(contact);
03182         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
03183     }
03184 
03201     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
03202     {
03203         if (!invalidationReason().isEmpty()) {
03204             return QDBusPendingReply<>(QDBusMessage::createError(
03205                 invalidationReason(),
03206                 invalidationMessage()
03207             ));
03208         }
03209 
03210 
03211         QList<QVariant> argumentList;
03212         argumentList << QVariant::fromValue(location);
03213         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
03214     }
03215 
03216 Q_SIGNALS:
03231     void LocationUpdated(uint contact, const QVariantMap& location);
03232 
03233 protected:
03234     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03235 };
03236 
03244 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
03245 {
03246     Q_OBJECT
03247 
03248 public:
03255     static inline const char *staticInterfaceName()
03256     {
03257         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
03258     }
03259 
03267     ConnectionInterfacePresenceInterface(
03268         const QString& busName,
03269         const QString& objectPath,
03270         QObject* parent = 0
03271     );
03272 
03281     ConnectionInterfacePresenceInterface(
03282         const QDBusConnection& connection,
03283         const QString& busName,
03284         const QString& objectPath,
03285         QObject* parent = 0
03286     );
03287 
03294     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
03295 
03303     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
03304 
03312     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03313 
03314 public Q_SLOTS:
03331     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
03332     {
03333         if (!invalidationReason().isEmpty()) {
03334             return QDBusPendingReply<>(QDBusMessage::createError(
03335                 invalidationReason(),
03336                 invalidationMessage()
03337             ));
03338         }
03339 
03340 
03341         QList<QVariant> argumentList;
03342         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
03343         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
03344     }
03345 
03354     inline QDBusPendingReply<> ClearStatus()
03355     {
03356         if (!invalidationReason().isEmpty()) {
03357             return QDBusPendingReply<>(QDBusMessage::createError(
03358                 invalidationReason(),
03359                 invalidationMessage()
03360             ));
03361         }
03362 
03363 
03364         return asyncCall(QLatin1String("ClearStatus"));
03365     }
03366 
03385     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
03386     {
03387         if (!invalidationReason().isEmpty()) {
03388             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
03389                 invalidationReason(),
03390                 invalidationMessage()
03391             ));
03392         }
03393 
03394 
03395         QList<QVariant> argumentList;
03396         argumentList << QVariant::fromValue(contacts);
03397         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
03398     }
03399 
03416     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
03417     {
03418         if (!invalidationReason().isEmpty()) {
03419             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
03420                 invalidationReason(),
03421                 invalidationMessage()
03422             ));
03423         }
03424 
03425 
03426         return asyncCall(QLatin1String("GetStatuses"));
03427     }
03428 
03442     inline QDBusPendingReply<> RemoveStatus(const QString& status)
03443     {
03444         if (!invalidationReason().isEmpty()) {
03445             return QDBusPendingReply<>(QDBusMessage::createError(
03446                 invalidationReason(),
03447                 invalidationMessage()
03448             ));
03449         }
03450 
03451 
03452         QList<QVariant> argumentList;
03453         argumentList << QVariant::fromValue(status);
03454         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
03455     }
03456 
03470     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
03471     {
03472         if (!invalidationReason().isEmpty()) {
03473             return QDBusPendingReply<>(QDBusMessage::createError(
03474                 invalidationReason(),
03475                 invalidationMessage()
03476             ));
03477         }
03478 
03479 
03480         QList<QVariant> argumentList;
03481         argumentList << QVariant::fromValue(contacts);
03482         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
03483     }
03484 
03495     inline QDBusPendingReply<> SetLastActivityTime(uint time)
03496     {
03497         if (!invalidationReason().isEmpty()) {
03498             return QDBusPendingReply<>(QDBusMessage::createError(
03499                 invalidationReason(),
03500                 invalidationMessage()
03501             ));
03502         }
03503 
03504 
03505         QList<QVariant> argumentList;
03506         argumentList << QVariant::fromValue(time);
03507         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
03508     }
03509 
03540     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
03541     {
03542         if (!invalidationReason().isEmpty()) {
03543             return QDBusPendingReply<>(QDBusMessage::createError(
03544                 invalidationReason(),
03545                 invalidationMessage()
03546             ));
03547         }
03548 
03549 
03550         QList<QVariant> argumentList;
03551         argumentList << QVariant::fromValue(statuses);
03552         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
03553     }
03554 
03555 Q_SIGNALS:
03572     void PresenceUpdate(const Tp::ContactPresences& presence);
03573 
03574 protected:
03575     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03576 };
03577 
03585 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
03586 {
03587     Q_OBJECT
03588 
03589 public:
03596     static inline const char *staticInterfaceName()
03597     {
03598         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
03599     }
03600 
03608     ConnectionInterfaceRequestsInterface(
03609         const QString& busName,
03610         const QString& objectPath,
03611         QObject* parent = 0
03612     );
03613 
03622     ConnectionInterfaceRequestsInterface(
03623         const QDBusConnection& connection,
03624         const QString& busName,
03625         const QString& objectPath,
03626         QObject* parent = 0
03627     );
03628 
03635     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
03636 
03644     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03645 
03653     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03654 
03661     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
03662 
03663     
03671     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
03672     {
03673         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
03674     }
03675 
03699     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
03700 
03701     
03709     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
03710     {
03711         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
03712     }
03713 
03714 public Q_SLOTS:
03783     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
03784     {
03785         if (!invalidationReason().isEmpty()) {
03786             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03787                 invalidationReason(),
03788                 invalidationMessage()
03789             ));
03790         }
03791 
03792 
03793         QList<QVariant> argumentList;
03794         argumentList << QVariant::fromValue(request);
03795         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
03796     }
03797 
03849     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
03850     {
03851         if (!invalidationReason().isEmpty()) {
03852             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03853                 invalidationReason(),
03854                 invalidationMessage()
03855             ));
03856         }
03857 
03858 
03859         QList<QVariant> argumentList;
03860         argumentList << QVariant::fromValue(request);
03861         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
03862     }
03863 
03864 Q_SIGNALS:
03906     void NewChannels(const Tp::ChannelDetailsList& channels);
03907 
03920     void ChannelClosed(const QDBusObjectPath& removed);
03921 
03922 protected:
03923     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03924 };
03925 
03933 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
03934 {
03935     Q_OBJECT
03936 
03937 public:
03944     static inline const char *staticInterfaceName()
03945     {
03946         return "org.freedesktop.Telepathy.Connection.Interface.ServicePoint";
03947     }
03948 
03956     ConnectionInterfaceServicePointInterface(
03957         const QString& busName,
03958         const QString& objectPath,
03959         QObject* parent = 0
03960     );
03961 
03970     ConnectionInterfaceServicePointInterface(
03971         const QDBusConnection& connection,
03972         const QString& busName,
03973         const QString& objectPath,
03974         QObject* parent = 0
03975     );
03976 
03983     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
03984 
03992     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
03993 
04001     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04002 
04008     Q_PROPERTY(Tp::ServicePointInfoList KnownServicePoints READ KnownServicePoints)
04009 
04010     
04018     inline Tp::ServicePointInfoList KnownServicePoints() const TELEPATHY_GNUC_DEPRECATED
04019     {
04020         return qvariant_cast<Tp::ServicePointInfoList>(internalPropGet("KnownServicePoints"));
04021     }
04022 
04023 Q_SIGNALS:
04035     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
04036 
04037 protected:
04038     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04039 };
04040 
04048 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
04049 {
04050     Q_OBJECT
04051 
04052 public:
04059     static inline const char *staticInterfaceName()
04060     {
04061         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
04062     }
04063 
04071     ConnectionInterfaceSimplePresenceInterface(
04072         const QString& busName,
04073         const QString& objectPath,
04074         QObject* parent = 0
04075     );
04076 
04085     ConnectionInterfaceSimplePresenceInterface(
04086         const QDBusConnection& connection,
04087         const QString& busName,
04088         const QString& objectPath,
04089         QObject* parent = 0
04090     );
04091 
04098     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
04099 
04107     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
04108 
04116     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04117 
04153     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
04154 
04155     
04163     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
04164     {
04165         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
04166     }
04167 
04168 public Q_SLOTS:
04223     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
04224     {
04225         if (!invalidationReason().isEmpty()) {
04226             return QDBusPendingReply<>(QDBusMessage::createError(
04227                 invalidationReason(),
04228                 invalidationMessage()
04229             ));
04230         }
04231 
04232 
04233         QList<QVariant> argumentList;
04234         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
04235         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
04236     }
04237 
04262     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
04263     {
04264         if (!invalidationReason().isEmpty()) {
04265             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
04266                 invalidationReason(),
04267                 invalidationMessage()
04268             ));
04269         }
04270 
04271 
04272         QList<QVariant> argumentList;
04273         argumentList << QVariant::fromValue(contacts);
04274         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
04275     }
04276 
04277 Q_SIGNALS:
04290     void PresencesChanged(const Tp::SimpleContactPresences& presence);
04291 
04292 protected:
04293     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04294 };
04295 }
04296 }
04297 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
04298 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
04299 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
04300 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
04301 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
04302 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
04303 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
04304 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
04305 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
04306 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
04307 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
04308 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
04309 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
04310 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
04311 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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