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 
00699     void ConnectionError(const QString& error, const QVariantMap& details);
00700 
00717     void StatusChanged(uint status, uint reason);
00718 
00719 protected:
00720     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00721 };
00722 
00730 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00731 {
00732     Q_OBJECT
00733 
00734 public:
00741     static inline const char *staticInterfaceName()
00742     {
00743         return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
00744     }
00745 
00753     ConnectionInterfaceAliasingInterface(
00754         const QString& busName,
00755         const QString& objectPath,
00756         QObject* parent = 0
00757     );
00758 
00767     ConnectionInterfaceAliasingInterface(
00768         const QDBusConnection& connection,
00769         const QString& busName,
00770         const QString& objectPath,
00771         QObject* parent = 0
00772     );
00773 
00780     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
00781 
00789     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
00790 
00798     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00799 
00800 public Q_SLOTS:
00811     inline QDBusPendingReply<uint> GetAliasFlags()
00812     {
00813         if (!invalidationReason().isEmpty()) {
00814             return QDBusPendingReply<uint>(QDBusMessage::createError(
00815                 invalidationReason(),
00816                 invalidationMessage()
00817             ));
00818         }
00819 
00820 
00821         return asyncCall(QLatin1String("GetAliasFlags"));
00822     }
00823 
00837     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
00838     {
00839         if (!invalidationReason().isEmpty()) {
00840             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00841                 invalidationReason(),
00842                 invalidationMessage()
00843             ));
00844         }
00845 
00846 
00847         QList<QVariant> argumentList;
00848         argumentList << QVariant::fromValue(contacts);
00849         return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
00850     }
00851 
00869     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
00870     {
00871         if (!invalidationReason().isEmpty()) {
00872             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
00873                 invalidationReason(),
00874                 invalidationMessage()
00875             ));
00876         }
00877 
00878 
00879         QList<QVariant> argumentList;
00880         argumentList << QVariant::fromValue(contacts);
00881         return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
00882     }
00883 
00898     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
00899     {
00900         if (!invalidationReason().isEmpty()) {
00901             return QDBusPendingReply<>(QDBusMessage::createError(
00902                 invalidationReason(),
00903                 invalidationMessage()
00904             ));
00905         }
00906 
00907 
00908         QList<QVariant> argumentList;
00909         argumentList << QVariant::fromValue(aliases);
00910         return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
00911     }
00912 
00913 Q_SIGNALS:
00928     void AliasesChanged(const Tp::AliasPairList& aliases);
00929 
00930 protected:
00931     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00932 };
00933 
00941 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
00942 {
00943     Q_OBJECT
00944 
00945 public:
00952     static inline const char *staticInterfaceName()
00953     {
00954         return "org.freedesktop.Telepathy.Connection.Interface.Anonymity";
00955     }
00956 
00964     ConnectionInterfaceAnonymityInterface(
00965         const QString& busName,
00966         const QString& objectPath,
00967         QObject* parent = 0
00968     );
00969 
00978     ConnectionInterfaceAnonymityInterface(
00979         const QDBusConnection& connection,
00980         const QString& busName,
00981         const QString& objectPath,
00982         QObject* parent = 0
00983     );
00984 
00991     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00992 
01000     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01001 
01009     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01010 
01017     Q_PROPERTY(uint SupportedAnonymityModes READ SupportedAnonymityModes)
01018 
01019     
01027     inline uint SupportedAnonymityModes() const TELEPATHY_GNUC_DEPRECATED
01028     {
01029         return qvariant_cast<uint>(internalPropGet("SupportedAnonymityModes"));
01030     }
01031 
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 
01092     Q_PROPERTY(uint AnonymityModes READ AnonymityModes WRITE setAnonymityModes)
01093 
01094     
01102     inline uint AnonymityModes() const TELEPATHY_GNUC_DEPRECATED
01103     {
01104         return qvariant_cast<uint>(internalPropGet("AnonymityModes"));
01105     }
01106 
01114     inline void setAnonymityModes(uint newValue) TELEPATHY_GNUC_DEPRECATED
01115     {
01116         internalPropSet("AnonymityModes", QVariant::fromValue(newValue));
01117     }
01118 
01119 Q_SIGNALS:
01129     void AnonymityModesChanged(uint modes);
01130 
01131 protected:
01132     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01133 };
01134 
01142 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01143 {
01144     Q_OBJECT
01145 
01146 public:
01153     static inline const char *staticInterfaceName()
01154     {
01155         return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
01156     }
01157 
01165     ConnectionInterfaceAvatarsInterface(
01166         const QString& busName,
01167         const QString& objectPath,
01168         QObject* parent = 0
01169     );
01170 
01179     ConnectionInterfaceAvatarsInterface(
01180         const QDBusConnection& connection,
01181         const QString& busName,
01182         const QString& objectPath,
01183         QObject* parent = 0
01184     );
01185 
01192     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01193 
01201     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01202 
01210     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01211 
01219     Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
01220 
01221     
01229     inline QStringList SupportedAvatarMIMETypes() const TELEPATHY_GNUC_DEPRECATED
01230     {
01231         return qvariant_cast<QStringList>(internalPropGet("SupportedAvatarMIMETypes"));
01232     }
01233 
01241     Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
01242 
01243     
01251     inline uint MinimumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01252     {
01253         return qvariant_cast<uint>(internalPropGet("MinimumAvatarHeight"));
01254     }
01255 
01263     Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
01264 
01265     
01273     inline uint MinimumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01274     {
01275         return qvariant_cast<uint>(internalPropGet("MinimumAvatarWidth"));
01276     }
01277 
01288     Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
01289 
01290     
01298     inline uint RecommendedAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01299     {
01300         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarHeight"));
01301     }
01302 
01311     Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
01312 
01313     
01321     inline uint RecommendedAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01322     {
01323         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarWidth"));
01324     }
01325 
01333     Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
01334 
01335     
01343     inline uint MaximumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01344     {
01345         return qvariant_cast<uint>(internalPropGet("MaximumAvatarHeight"));
01346     }
01347 
01355     Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
01356 
01357     
01365     inline uint MaximumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01366     {
01367         return qvariant_cast<uint>(internalPropGet("MaximumAvatarWidth"));
01368     }
01369 
01377     Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
01378 
01379     
01387     inline uint MaximumAvatarBytes() const TELEPATHY_GNUC_DEPRECATED
01388     {
01389         return qvariant_cast<uint>(internalPropGet("MaximumAvatarBytes"));
01390     }
01391 
01392 public Q_SLOTS:
01422     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
01423     {
01424         if (!invalidationReason().isEmpty()) {
01425             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01426                 invalidationReason(),
01427                 invalidationMessage()
01428             ));
01429         }
01430 
01431 
01432         return asyncCall(QLatin1String("GetAvatarRequirements"));
01433     }
01434 
01451     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
01452     {
01453         if (!invalidationReason().isEmpty()) {
01454             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01455                 invalidationReason(),
01456                 invalidationMessage()
01457             ));
01458         }
01459 
01460 
01461         QList<QVariant> argumentList;
01462         argumentList << QVariant::fromValue(contacts);
01463         return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
01464     }
01465 
01488     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
01489     {
01490         if (!invalidationReason().isEmpty()) {
01491             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01492                 invalidationReason(),
01493                 invalidationMessage()
01494             ));
01495         }
01496 
01497 
01498         QList<QVariant> argumentList;
01499         argumentList << QVariant::fromValue(contacts);
01500         return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
01501     }
01502 
01522     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
01523     {
01524         if (!invalidationReason().isEmpty()) {
01525             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01526                 invalidationReason(),
01527                 invalidationMessage()
01528             ));
01529         }
01530 
01531 
01532         QList<QVariant> argumentList;
01533         argumentList << QVariant::fromValue(contact);
01534         return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
01535     }
01536 
01550     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
01551     {
01552         if (!invalidationReason().isEmpty()) {
01553             return QDBusPendingReply<>(QDBusMessage::createError(
01554                 invalidationReason(),
01555                 invalidationMessage()
01556             ));
01557         }
01558 
01559 
01560         QList<QVariant> argumentList;
01561         argumentList << QVariant::fromValue(contacts);
01562         return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
01563     }
01564 
01583     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
01584     {
01585         if (!invalidationReason().isEmpty()) {
01586             return QDBusPendingReply<QString>(QDBusMessage::createError(
01587                 invalidationReason(),
01588                 invalidationMessage()
01589             ));
01590         }
01591 
01592 
01593         QList<QVariant> argumentList;
01594         argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01595         return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
01596     }
01597 
01603     inline QDBusPendingReply<> ClearAvatar()
01604     {
01605         if (!invalidationReason().isEmpty()) {
01606             return QDBusPendingReply<>(QDBusMessage::createError(
01607                 invalidationReason(),
01608                 invalidationMessage()
01609             ));
01610         }
01611 
01612 
01613         return asyncCall(QLatin1String("ClearAvatar"));
01614     }
01615 
01616 Q_SIGNALS:
01633     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01634 
01657     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01658 
01659 protected:
01660     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01661 };
01662 
01670 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01671 {
01672     Q_OBJECT
01673 
01674 public:
01681     static inline const char *staticInterfaceName()
01682     {
01683         return "org.freedesktop.Telepathy.Connection.Interface.Balance";
01684     }
01685 
01693     ConnectionInterfaceBalanceInterface(
01694         const QString& busName,
01695         const QString& objectPath,
01696         QObject* parent = 0
01697     );
01698 
01707     ConnectionInterfaceBalanceInterface(
01708         const QDBusConnection& connection,
01709         const QString& busName,
01710         const QString& objectPath,
01711         QObject* parent = 0
01712     );
01713 
01720     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01721 
01729     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01730 
01738     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01739 
01752     Q_PROPERTY(Tp::CurrencyAmount AccountBalance READ AccountBalance)
01753 
01754     
01762     inline Tp::CurrencyAmount AccountBalance() const TELEPATHY_GNUC_DEPRECATED
01763     {
01764         return qvariant_cast<Tp::CurrencyAmount>(internalPropGet("AccountBalance"));
01765     }
01766 
01767 Q_SIGNALS:
01778     void BalanceChanged(const Tp::CurrencyAmount& balance);
01779 
01780 protected:
01781     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01782 };
01783 
01791 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
01792 {
01793     Q_OBJECT
01794 
01795 public:
01802     static inline const char *staticInterfaceName()
01803     {
01804         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
01805     }
01806 
01814     ConnectionInterfaceCapabilitiesInterface(
01815         const QString& busName,
01816         const QString& objectPath,
01817         QObject* parent = 0
01818     );
01819 
01828     ConnectionInterfaceCapabilitiesInterface(
01829         const QDBusConnection& connection,
01830         const QString& busName,
01831         const QString& objectPath,
01832         QObject* parent = 0
01833     );
01834 
01841     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
01842 
01850     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01851 
01859     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01860 
01861 public Q_SLOTS:
01906     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
01907     {
01908         if (!invalidationReason().isEmpty()) {
01909             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
01910                 invalidationReason(),
01911                 invalidationMessage()
01912             ));
01913         }
01914 
01915 
01916         QList<QVariant> argumentList;
01917         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
01918         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
01919     }
01920 
01946     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
01947     {
01948         if (!invalidationReason().isEmpty()) {
01949             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
01950                 invalidationReason(),
01951                 invalidationMessage()
01952             ));
01953         }
01954 
01955 
01956         QList<QVariant> argumentList;
01957         argumentList << QVariant::fromValue(handles);
01958         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
01959     }
01960 
01961 Q_SIGNALS:
01984     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
01985 
01986 protected:
01987     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01988 };
01989 
01997 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
01998 {
01999     Q_OBJECT
02000 
02001 public:
02008     static inline const char *staticInterfaceName()
02009     {
02010         return "org.freedesktop.Telepathy.Connection.Interface.Cellular";
02011     }
02012 
02020     ConnectionInterfaceCellularInterface(
02021         const QString& busName,
02022         const QString& objectPath,
02023         QObject* parent = 0
02024     );
02025 
02034     ConnectionInterfaceCellularInterface(
02035         const QDBusConnection& connection,
02036         const QString& busName,
02037         const QString& objectPath,
02038         QObject* parent = 0
02039     );
02040 
02047     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02048 
02056     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02057 
02065     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02066 
02095     Q_PROPERTY(uint MessageValidityPeriod READ MessageValidityPeriod WRITE setMessageValidityPeriod)
02096 
02097     
02105     inline uint MessageValidityPeriod() const TELEPATHY_GNUC_DEPRECATED
02106     {
02107         return qvariant_cast<uint>(internalPropGet("MessageValidityPeriod"));
02108     }
02109 
02117     inline void setMessageValidityPeriod(uint newValue) TELEPATHY_GNUC_DEPRECATED
02118     {
02119         internalPropSet("MessageValidityPeriod", QVariant::fromValue(newValue));
02120     }
02121 
02145     Q_PROPERTY(QString MessageServiceCentre READ MessageServiceCentre WRITE setMessageServiceCentre)
02146 
02147     
02155     inline QString MessageServiceCentre() const TELEPATHY_GNUC_DEPRECATED
02156     {
02157         return qvariant_cast<QString>(internalPropGet("MessageServiceCentre"));
02158     }
02159 
02167     inline void setMessageServiceCentre(const QString& newValue) TELEPATHY_GNUC_DEPRECATED
02168     {
02169         internalPropSet("MessageServiceCentre", QVariant::fromValue(newValue));
02170     }
02171 
02179     Q_PROPERTY(QString IMSI READ IMSI)
02180 
02181     
02189     inline QString IMSI() const TELEPATHY_GNUC_DEPRECATED
02190     {
02191         return qvariant_cast<QString>(internalPropGet("IMSI"));
02192     }
02193 
02221     Q_PROPERTY(bool MessageReducedCharacterSet READ MessageReducedCharacterSet WRITE setMessageReducedCharacterSet)
02222 
02223     
02231     inline bool MessageReducedCharacterSet() const TELEPATHY_GNUC_DEPRECATED
02232     {
02233         return qvariant_cast<bool>(internalPropGet("MessageReducedCharacterSet"));
02234     }
02235 
02243     inline void setMessageReducedCharacterSet(bool newValue) TELEPATHY_GNUC_DEPRECATED
02244     {
02245         internalPropSet("MessageReducedCharacterSet", QVariant::fromValue(newValue));
02246     }
02247 
02248 Q_SIGNALS:
02264     void IMSIChanged(const QString& IMSI);
02265 
02266 protected:
02267     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02268 };
02269 
02277 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
02278 {
02279     Q_OBJECT
02280 
02281 public:
02288     static inline const char *staticInterfaceName()
02289     {
02290         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
02291     }
02292 
02300     ConnectionInterfaceContactCapabilitiesInterface(
02301         const QString& busName,
02302         const QString& objectPath,
02303         QObject* parent = 0
02304     );
02305 
02314     ConnectionInterfaceContactCapabilitiesInterface(
02315         const QDBusConnection& connection,
02316         const QString& busName,
02317         const QString& objectPath,
02318         QObject* parent = 0
02319     );
02320 
02327     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
02328 
02336     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02337 
02345     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02346 
02347 public Q_SLOTS:
02403     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
02404     {
02405         if (!invalidationReason().isEmpty()) {
02406             return QDBusPendingReply<>(QDBusMessage::createError(
02407                 invalidationReason(),
02408                 invalidationMessage()
02409             ));
02410         }
02411 
02412 
02413         QList<QVariant> argumentList;
02414         argumentList << QVariant::fromValue(handlerCapabilities);
02415         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
02416     }
02417 
02442     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
02443     {
02444         if (!invalidationReason().isEmpty()) {
02445             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
02446                 invalidationReason(),
02447                 invalidationMessage()
02448             ));
02449         }
02450 
02451 
02452         QList<QVariant> argumentList;
02453         argumentList << QVariant::fromValue(handles);
02454         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
02455     }
02456 
02457 Q_SIGNALS:
02474     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
02475 
02476 protected:
02477     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02478 };
02479 
02487 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
02488 {
02489     Q_OBJECT
02490 
02491 public:
02498     static inline const char *staticInterfaceName()
02499     {
02500         return "org.freedesktop.Telepathy.Connection.Interface.ContactInfo";
02501     }
02502 
02510     ConnectionInterfaceContactInfoInterface(
02511         const QString& busName,
02512         const QString& objectPath,
02513         QObject* parent = 0
02514     );
02515 
02524     ConnectionInterfaceContactInfoInterface(
02525         const QDBusConnection& connection,
02526         const QString& busName,
02527         const QString& objectPath,
02528         QObject* parent = 0
02529     );
02530 
02537     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
02538 
02546     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
02547 
02555     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02556 
02574     Q_PROPERTY(uint ContactInfoFlags READ ContactInfoFlags)
02575 
02576     
02584     inline uint ContactInfoFlags() const TELEPATHY_GNUC_DEPRECATED
02585     {
02586         return qvariant_cast<uint>(internalPropGet("ContactInfoFlags"));
02587     }
02588 
02640     Q_PROPERTY(Tp::FieldSpecs SupportedFields READ SupportedFields)
02641 
02642     
02650     inline Tp::FieldSpecs SupportedFields() const TELEPATHY_GNUC_DEPRECATED
02651     {
02652         return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
02653     }
02654 
02655 public Q_SLOTS:
02673     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
02674     {
02675         if (!invalidationReason().isEmpty()) {
02676             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
02677                 invalidationReason(),
02678                 invalidationMessage()
02679             ));
02680         }
02681 
02682 
02683         QList<QVariant> argumentList;
02684         argumentList << QVariant::fromValue(contacts);
02685         return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
02686     }
02687 
02702     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
02703     {
02704         if (!invalidationReason().isEmpty()) {
02705             return QDBusPendingReply<>(QDBusMessage::createError(
02706                 invalidationReason(),
02707                 invalidationMessage()
02708             ));
02709         }
02710 
02711 
02712         QList<QVariant> argumentList;
02713         argumentList << QVariant::fromValue(contacts);
02714         return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
02715     }
02716 
02733     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
02734     {
02735         if (!invalidationReason().isEmpty()) {
02736             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
02737                 invalidationReason(),
02738                 invalidationMessage()
02739             ));
02740         }
02741 
02742 
02743         QList<QVariant> argumentList;
02744         argumentList << QVariant::fromValue(contact);
02745         return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
02746     }
02747 
02760     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
02761     {
02762         if (!invalidationReason().isEmpty()) {
02763             return QDBusPendingReply<>(QDBusMessage::createError(
02764                 invalidationReason(),
02765                 invalidationMessage()
02766             ));
02767         }
02768 
02769 
02770         QList<QVariant> argumentList;
02771         argumentList << QVariant::fromValue(contactInfo);
02772         return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
02773     }
02774 
02775 Q_SIGNALS:
02790     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
02791 
02792 protected:
02793     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02794 };
02795 
02803 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
02804 {
02805     Q_OBJECT
02806 
02807 public:
02814     static inline const char *staticInterfaceName()
02815     {
02816         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
02817     }
02818 
02826     ConnectionInterfaceContactsInterface(
02827         const QString& busName,
02828         const QString& objectPath,
02829         QObject* parent = 0
02830     );
02831 
02840     ConnectionInterfaceContactsInterface(
02841         const QDBusConnection& connection,
02842         const QString& busName,
02843         const QString& objectPath,
02844         QObject* parent = 0
02845     );
02846 
02853     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
02854 
02862     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02863 
02871     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02872 
02879     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
02880 
02881     
02889     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
02890     {
02891         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
02892     }
02893 
02894 public Q_SLOTS:
02960     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
02961     {
02962         if (!invalidationReason().isEmpty()) {
02963             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
02964                 invalidationReason(),
02965                 invalidationMessage()
02966             ));
02967         }
02968 
02969 
02970         QList<QVariant> argumentList;
02971         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
02972         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
02973     }
02974 
02975 protected:
02976     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02977 };
02978 
02986 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
02987 {
02988     Q_OBJECT
02989 
02990 public:
02997     static inline const char *staticInterfaceName()
02998     {
02999         return "org.freedesktop.Telepathy.Connection.Interface.Location";
03000     }
03001 
03009     ConnectionInterfaceLocationInterface(
03010         const QString& busName,
03011         const QString& objectPath,
03012         QObject* parent = 0
03013     );
03014 
03023     ConnectionInterfaceLocationInterface(
03024         const QDBusConnection& connection,
03025         const QString& busName,
03026         const QString& objectPath,
03027         QObject* parent = 0
03028     );
03029 
03036     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
03037 
03045     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
03046 
03054     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03055 
03061     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
03062 
03063     
03071     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
03072     {
03073         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
03074     }
03075 
03084     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
03085 
03086     
03094     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
03095     {
03096         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
03097     }
03098 
03106     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
03107     {
03108         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
03109     }
03110 
03118     Q_PROPERTY(uint SupportedLocationFeatures READ SupportedLocationFeatures)
03119 
03120     
03128     inline uint SupportedLocationFeatures() const TELEPATHY_GNUC_DEPRECATED
03129     {
03130         return qvariant_cast<uint>(internalPropGet("SupportedLocationFeatures"));
03131     }
03132 
03133 public Q_SLOTS:
03157     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
03158     {
03159         if (!invalidationReason().isEmpty()) {
03160             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
03161                 invalidationReason(),
03162                 invalidationMessage()
03163             ));
03164         }
03165 
03166 
03167         QList<QVariant> argumentList;
03168         argumentList << QVariant::fromValue(contacts);
03169         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
03170     }
03171 
03191     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
03192     {
03193         if (!invalidationReason().isEmpty()) {
03194             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
03195                 invalidationReason(),
03196                 invalidationMessage()
03197             ));
03198         }
03199 
03200 
03201         QList<QVariant> argumentList;
03202         argumentList << QVariant::fromValue(contact);
03203         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
03204     }
03205 
03222     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
03223     {
03224         if (!invalidationReason().isEmpty()) {
03225             return QDBusPendingReply<>(QDBusMessage::createError(
03226                 invalidationReason(),
03227                 invalidationMessage()
03228             ));
03229         }
03230 
03231 
03232         QList<QVariant> argumentList;
03233         argumentList << QVariant::fromValue(location);
03234         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
03235     }
03236 
03237 Q_SIGNALS:
03252     void LocationUpdated(uint contact, const QVariantMap& location);
03253 
03254 protected:
03255     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03256 };
03257 
03265 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
03266 {
03267     Q_OBJECT
03268 
03269 public:
03276     static inline const char *staticInterfaceName()
03277     {
03278         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
03279     }
03280 
03288     ConnectionInterfacePresenceInterface(
03289         const QString& busName,
03290         const QString& objectPath,
03291         QObject* parent = 0
03292     );
03293 
03302     ConnectionInterfacePresenceInterface(
03303         const QDBusConnection& connection,
03304         const QString& busName,
03305         const QString& objectPath,
03306         QObject* parent = 0
03307     );
03308 
03315     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
03316 
03324     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
03325 
03333     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03334 
03335 public Q_SLOTS:
03352     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
03353     {
03354         if (!invalidationReason().isEmpty()) {
03355             return QDBusPendingReply<>(QDBusMessage::createError(
03356                 invalidationReason(),
03357                 invalidationMessage()
03358             ));
03359         }
03360 
03361 
03362         QList<QVariant> argumentList;
03363         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
03364         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
03365     }
03366 
03375     inline QDBusPendingReply<> ClearStatus()
03376     {
03377         if (!invalidationReason().isEmpty()) {
03378             return QDBusPendingReply<>(QDBusMessage::createError(
03379                 invalidationReason(),
03380                 invalidationMessage()
03381             ));
03382         }
03383 
03384 
03385         return asyncCall(QLatin1String("ClearStatus"));
03386     }
03387 
03406     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
03407     {
03408         if (!invalidationReason().isEmpty()) {
03409             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
03410                 invalidationReason(),
03411                 invalidationMessage()
03412             ));
03413         }
03414 
03415 
03416         QList<QVariant> argumentList;
03417         argumentList << QVariant::fromValue(contacts);
03418         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
03419     }
03420 
03437     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
03438     {
03439         if (!invalidationReason().isEmpty()) {
03440             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
03441                 invalidationReason(),
03442                 invalidationMessage()
03443             ));
03444         }
03445 
03446 
03447         return asyncCall(QLatin1String("GetStatuses"));
03448     }
03449 
03463     inline QDBusPendingReply<> RemoveStatus(const QString& status)
03464     {
03465         if (!invalidationReason().isEmpty()) {
03466             return QDBusPendingReply<>(QDBusMessage::createError(
03467                 invalidationReason(),
03468                 invalidationMessage()
03469             ));
03470         }
03471 
03472 
03473         QList<QVariant> argumentList;
03474         argumentList << QVariant::fromValue(status);
03475         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
03476     }
03477 
03491     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
03492     {
03493         if (!invalidationReason().isEmpty()) {
03494             return QDBusPendingReply<>(QDBusMessage::createError(
03495                 invalidationReason(),
03496                 invalidationMessage()
03497             ));
03498         }
03499 
03500 
03501         QList<QVariant> argumentList;
03502         argumentList << QVariant::fromValue(contacts);
03503         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
03504     }
03505 
03516     inline QDBusPendingReply<> SetLastActivityTime(uint time)
03517     {
03518         if (!invalidationReason().isEmpty()) {
03519             return QDBusPendingReply<>(QDBusMessage::createError(
03520                 invalidationReason(),
03521                 invalidationMessage()
03522             ));
03523         }
03524 
03525 
03526         QList<QVariant> argumentList;
03527         argumentList << QVariant::fromValue(time);
03528         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
03529     }
03530 
03561     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
03562     {
03563         if (!invalidationReason().isEmpty()) {
03564             return QDBusPendingReply<>(QDBusMessage::createError(
03565                 invalidationReason(),
03566                 invalidationMessage()
03567             ));
03568         }
03569 
03570 
03571         QList<QVariant> argumentList;
03572         argumentList << QVariant::fromValue(statuses);
03573         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
03574     }
03575 
03576 Q_SIGNALS:
03593     void PresenceUpdate(const Tp::ContactPresences& presence);
03594 
03595 protected:
03596     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03597 };
03598 
03606 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
03607 {
03608     Q_OBJECT
03609 
03610 public:
03617     static inline const char *staticInterfaceName()
03618     {
03619         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
03620     }
03621 
03629     ConnectionInterfaceRequestsInterface(
03630         const QString& busName,
03631         const QString& objectPath,
03632         QObject* parent = 0
03633     );
03634 
03643     ConnectionInterfaceRequestsInterface(
03644         const QDBusConnection& connection,
03645         const QString& busName,
03646         const QString& objectPath,
03647         QObject* parent = 0
03648     );
03649 
03656     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
03657 
03665     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03666 
03674     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03675 
03682     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
03683 
03684     
03692     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
03693     {
03694         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
03695     }
03696 
03720     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
03721 
03722     
03730     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
03731     {
03732         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
03733     }
03734 
03735 public Q_SLOTS:
03804     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
03805     {
03806         if (!invalidationReason().isEmpty()) {
03807             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03808                 invalidationReason(),
03809                 invalidationMessage()
03810             ));
03811         }
03812 
03813 
03814         QList<QVariant> argumentList;
03815         argumentList << QVariant::fromValue(request);
03816         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
03817     }
03818 
03870     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
03871     {
03872         if (!invalidationReason().isEmpty()) {
03873             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03874                 invalidationReason(),
03875                 invalidationMessage()
03876             ));
03877         }
03878 
03879 
03880         QList<QVariant> argumentList;
03881         argumentList << QVariant::fromValue(request);
03882         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
03883     }
03884 
03885 Q_SIGNALS:
03927     void NewChannels(const Tp::ChannelDetailsList& channels);
03928 
03941     void ChannelClosed(const QDBusObjectPath& removed);
03942 
03943 protected:
03944     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03945 };
03946 
03954 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
03955 {
03956     Q_OBJECT
03957 
03958 public:
03965     static inline const char *staticInterfaceName()
03966     {
03967         return "org.freedesktop.Telepathy.Connection.Interface.ServicePoint";
03968     }
03969 
03977     ConnectionInterfaceServicePointInterface(
03978         const QString& busName,
03979         const QString& objectPath,
03980         QObject* parent = 0
03981     );
03982 
03991     ConnectionInterfaceServicePointInterface(
03992         const QDBusConnection& connection,
03993         const QString& busName,
03994         const QString& objectPath,
03995         QObject* parent = 0
03996     );
03997 
04004     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
04005 
04013     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
04014 
04022     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04023 
04029     Q_PROPERTY(Tp::ServicePointInfoList KnownServicePoints READ KnownServicePoints)
04030 
04031     
04039     inline Tp::ServicePointInfoList KnownServicePoints() const TELEPATHY_GNUC_DEPRECATED
04040     {
04041         return qvariant_cast<Tp::ServicePointInfoList>(internalPropGet("KnownServicePoints"));
04042     }
04043 
04044 Q_SIGNALS:
04056     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
04057 
04058 protected:
04059     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04060 };
04061 
04069 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
04070 {
04071     Q_OBJECT
04072 
04073 public:
04080     static inline const char *staticInterfaceName()
04081     {
04082         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
04083     }
04084 
04092     ConnectionInterfaceSimplePresenceInterface(
04093         const QString& busName,
04094         const QString& objectPath,
04095         QObject* parent = 0
04096     );
04097 
04106     ConnectionInterfaceSimplePresenceInterface(
04107         const QDBusConnection& connection,
04108         const QString& busName,
04109         const QString& objectPath,
04110         QObject* parent = 0
04111     );
04112 
04119     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
04120 
04128     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
04129 
04137     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04138 
04174     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
04175 
04176     
04184     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
04185     {
04186         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
04187     }
04188 
04189 public Q_SLOTS:
04244     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
04245     {
04246         if (!invalidationReason().isEmpty()) {
04247             return QDBusPendingReply<>(QDBusMessage::createError(
04248                 invalidationReason(),
04249                 invalidationMessage()
04250             ));
04251         }
04252 
04253 
04254         QList<QVariant> argumentList;
04255         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
04256         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
04257     }
04258 
04283     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
04284     {
04285         if (!invalidationReason().isEmpty()) {
04286             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
04287                 invalidationReason(),
04288                 invalidationMessage()
04289             ));
04290         }
04291 
04292 
04293         QList<QVariant> argumentList;
04294         argumentList << QVariant::fromValue(contacts);
04295         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
04296     }
04297 
04298 Q_SIGNALS:
04311     void PresencesChanged(const Tp::SimpleContactPresences& presence);
04312 
04313 protected:
04314     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04315 };
04316 }
04317 }
04318 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
04319 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
04320 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
04321 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
04322 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
04323 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
04324 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
04325 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
04326 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
04327 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
04328 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
04329 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
04330 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
04331 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
04332 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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