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 
00698     void ConnectionError(const QString& error, const QVariantMap& details);
00699 
00716     void StatusChanged(uint status, uint reason);
00717 
00718 protected:
00719     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00720 };
00721 
00729 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00730 {
00731     Q_OBJECT
00732 
00733 public:
00740     static inline const char *staticInterfaceName()
00741     {
00742         return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
00743     }
00744 
00752     ConnectionInterfaceAliasingInterface(
00753         const QString& busName,
00754         const QString& objectPath,
00755         QObject* parent = 0
00756     );
00757 
00766     ConnectionInterfaceAliasingInterface(
00767         const QDBusConnection& connection,
00768         const QString& busName,
00769         const QString& objectPath,
00770         QObject* parent = 0
00771     );
00772 
00779     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
00780 
00788     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
00789 
00797     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00798 
00799 public Q_SLOTS:
00810     inline QDBusPendingReply<uint> GetAliasFlags()
00811     {
00812         if (!invalidationReason().isEmpty()) {
00813             return QDBusPendingReply<uint>(QDBusMessage::createError(
00814                 invalidationReason(),
00815                 invalidationMessage()
00816             ));
00817         }
00818 
00819 
00820         return asyncCall(QLatin1String("GetAliasFlags"));
00821     }
00822 
00836     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
00837     {
00838         if (!invalidationReason().isEmpty()) {
00839             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00840                 invalidationReason(),
00841                 invalidationMessage()
00842             ));
00843         }
00844 
00845 
00846         QList<QVariant> argumentList;
00847         argumentList << QVariant::fromValue(contacts);
00848         return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
00849     }
00850 
00868     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
00869     {
00870         if (!invalidationReason().isEmpty()) {
00871             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
00872                 invalidationReason(),
00873                 invalidationMessage()
00874             ));
00875         }
00876 
00877 
00878         QList<QVariant> argumentList;
00879         argumentList << QVariant::fromValue(contacts);
00880         return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
00881     }
00882 
00897     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
00898     {
00899         if (!invalidationReason().isEmpty()) {
00900             return QDBusPendingReply<>(QDBusMessage::createError(
00901                 invalidationReason(),
00902                 invalidationMessage()
00903             ));
00904         }
00905 
00906 
00907         QList<QVariant> argumentList;
00908         argumentList << QVariant::fromValue(aliases);
00909         return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
00910     }
00911 
00912 Q_SIGNALS:
00927     void AliasesChanged(const Tp::AliasPairList& aliases);
00928 
00929 protected:
00930     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00931 };
00932 
00940 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAnonymityInterface : public Tp::AbstractInterface
00941 {
00942     Q_OBJECT
00943 
00944 public:
00951     static inline const char *staticInterfaceName()
00952     {
00953         return "org.freedesktop.Telepathy.Connection.Interface.Anonymity";
00954     }
00955 
00963     ConnectionInterfaceAnonymityInterface(
00964         const QString& busName,
00965         const QString& objectPath,
00966         QObject* parent = 0
00967     );
00968 
00977     ConnectionInterfaceAnonymityInterface(
00978         const QDBusConnection& connection,
00979         const QString& busName,
00980         const QString& objectPath,
00981         QObject* parent = 0
00982     );
00983 
00990     ConnectionInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00991 
00999     explicit ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface);
01000 
01008     ConnectionInterfaceAnonymityInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01009 
01016     Q_PROPERTY(uint SupportedAnonymityModes READ SupportedAnonymityModes)
01017 
01018     
01026     inline uint SupportedAnonymityModes() const TELEPATHY_GNUC_DEPRECATED
01027     {
01028         return qvariant_cast<uint>(internalPropGet("SupportedAnonymityModes"));
01029     }
01030 
01049     Q_PROPERTY(bool AnonymityMandatory READ AnonymityMandatory WRITE setAnonymityMandatory)
01050 
01051     
01059     inline bool AnonymityMandatory() const TELEPATHY_GNUC_DEPRECATED
01060     {
01061         return qvariant_cast<bool>(internalPropGet("AnonymityMandatory"));
01062     }
01063 
01071     inline void setAnonymityMandatory(bool newValue) TELEPATHY_GNUC_DEPRECATED
01072     {
01073         internalPropSet("AnonymityMandatory", QVariant::fromValue(newValue));
01074     }
01075 
01091     Q_PROPERTY(uint AnonymityModes READ AnonymityModes WRITE setAnonymityModes)
01092 
01093     
01101     inline uint AnonymityModes() const TELEPATHY_GNUC_DEPRECATED
01102     {
01103         return qvariant_cast<uint>(internalPropGet("AnonymityModes"));
01104     }
01105 
01113     inline void setAnonymityModes(uint newValue) TELEPATHY_GNUC_DEPRECATED
01114     {
01115         internalPropSet("AnonymityModes", QVariant::fromValue(newValue));
01116     }
01117 
01118 Q_SIGNALS:
01128     void AnonymityModesChanged(uint modes);
01129 
01130 protected:
01131     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01132 };
01133 
01141 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
01142 {
01143     Q_OBJECT
01144 
01145 public:
01152     static inline const char *staticInterfaceName()
01153     {
01154         return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
01155     }
01156 
01164     ConnectionInterfaceAvatarsInterface(
01165         const QString& busName,
01166         const QString& objectPath,
01167         QObject* parent = 0
01168     );
01169 
01178     ConnectionInterfaceAvatarsInterface(
01179         const QDBusConnection& connection,
01180         const QString& busName,
01181         const QString& objectPath,
01182         QObject* parent = 0
01183     );
01184 
01191     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
01192 
01200     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01201 
01209     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01210 
01218     Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
01219 
01220     
01228     inline QStringList SupportedAvatarMIMETypes() const TELEPATHY_GNUC_DEPRECATED
01229     {
01230         return qvariant_cast<QStringList>(internalPropGet("SupportedAvatarMIMETypes"));
01231     }
01232 
01240     Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
01241 
01242     
01250     inline uint MinimumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01251     {
01252         return qvariant_cast<uint>(internalPropGet("MinimumAvatarHeight"));
01253     }
01254 
01262     Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
01263 
01264     
01272     inline uint MinimumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01273     {
01274         return qvariant_cast<uint>(internalPropGet("MinimumAvatarWidth"));
01275     }
01276 
01287     Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
01288 
01289     
01297     inline uint RecommendedAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01298     {
01299         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarHeight"));
01300     }
01301 
01310     Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
01311 
01312     
01320     inline uint RecommendedAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01321     {
01322         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarWidth"));
01323     }
01324 
01332     Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
01333 
01334     
01342     inline uint MaximumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01343     {
01344         return qvariant_cast<uint>(internalPropGet("MaximumAvatarHeight"));
01345     }
01346 
01354     Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
01355 
01356     
01364     inline uint MaximumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01365     {
01366         return qvariant_cast<uint>(internalPropGet("MaximumAvatarWidth"));
01367     }
01368 
01376     Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
01377 
01378     
01386     inline uint MaximumAvatarBytes() const TELEPATHY_GNUC_DEPRECATED
01387     {
01388         return qvariant_cast<uint>(internalPropGet("MaximumAvatarBytes"));
01389     }
01390 
01391 public Q_SLOTS:
01421     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
01422     {
01423         if (!invalidationReason().isEmpty()) {
01424             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01425                 invalidationReason(),
01426                 invalidationMessage()
01427             ));
01428         }
01429 
01430 
01431         return asyncCall(QLatin1String("GetAvatarRequirements"));
01432     }
01433 
01450     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
01451     {
01452         if (!invalidationReason().isEmpty()) {
01453             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01454                 invalidationReason(),
01455                 invalidationMessage()
01456             ));
01457         }
01458 
01459 
01460         QList<QVariant> argumentList;
01461         argumentList << QVariant::fromValue(contacts);
01462         return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
01463     }
01464 
01487     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
01488     {
01489         if (!invalidationReason().isEmpty()) {
01490             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01491                 invalidationReason(),
01492                 invalidationMessage()
01493             ));
01494         }
01495 
01496 
01497         QList<QVariant> argumentList;
01498         argumentList << QVariant::fromValue(contacts);
01499         return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
01500     }
01501 
01521     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
01522     {
01523         if (!invalidationReason().isEmpty()) {
01524             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01525                 invalidationReason(),
01526                 invalidationMessage()
01527             ));
01528         }
01529 
01530 
01531         QList<QVariant> argumentList;
01532         argumentList << QVariant::fromValue(contact);
01533         return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
01534     }
01535 
01549     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
01550     {
01551         if (!invalidationReason().isEmpty()) {
01552             return QDBusPendingReply<>(QDBusMessage::createError(
01553                 invalidationReason(),
01554                 invalidationMessage()
01555             ));
01556         }
01557 
01558 
01559         QList<QVariant> argumentList;
01560         argumentList << QVariant::fromValue(contacts);
01561         return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
01562     }
01563 
01582     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
01583     {
01584         if (!invalidationReason().isEmpty()) {
01585             return QDBusPendingReply<QString>(QDBusMessage::createError(
01586                 invalidationReason(),
01587                 invalidationMessage()
01588             ));
01589         }
01590 
01591 
01592         QList<QVariant> argumentList;
01593         argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01594         return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
01595     }
01596 
01602     inline QDBusPendingReply<> ClearAvatar()
01603     {
01604         if (!invalidationReason().isEmpty()) {
01605             return QDBusPendingReply<>(QDBusMessage::createError(
01606                 invalidationReason(),
01607                 invalidationMessage()
01608             ));
01609         }
01610 
01611 
01612         return asyncCall(QLatin1String("ClearAvatar"));
01613     }
01614 
01615 Q_SIGNALS:
01632     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01633 
01656     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01657 
01658 protected:
01659     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01660 };
01661 
01669 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01670 {
01671     Q_OBJECT
01672 
01673 public:
01680     static inline const char *staticInterfaceName()
01681     {
01682         return "org.freedesktop.Telepathy.Connection.Interface.Balance";
01683     }
01684 
01692     ConnectionInterfaceBalanceInterface(
01693         const QString& busName,
01694         const QString& objectPath,
01695         QObject* parent = 0
01696     );
01697 
01706     ConnectionInterfaceBalanceInterface(
01707         const QDBusConnection& connection,
01708         const QString& busName,
01709         const QString& objectPath,
01710         QObject* parent = 0
01711     );
01712 
01719     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01720 
01728     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01729 
01737     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01738 
01751     Q_PROPERTY(Tp::CurrencyAmount AccountBalance READ AccountBalance)
01752 
01753     
01761     inline Tp::CurrencyAmount AccountBalance() const TELEPATHY_GNUC_DEPRECATED
01762     {
01763         return qvariant_cast<Tp::CurrencyAmount>(internalPropGet("AccountBalance"));
01764     }
01765 
01766 Q_SIGNALS:
01777     void BalanceChanged(const Tp::CurrencyAmount& balance);
01778 
01779 protected:
01780     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01781 };
01782 
01790 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
01791 {
01792     Q_OBJECT
01793 
01794 public:
01801     static inline const char *staticInterfaceName()
01802     {
01803         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
01804     }
01805 
01813     ConnectionInterfaceCapabilitiesInterface(
01814         const QString& busName,
01815         const QString& objectPath,
01816         QObject* parent = 0
01817     );
01818 
01827     ConnectionInterfaceCapabilitiesInterface(
01828         const QDBusConnection& connection,
01829         const QString& busName,
01830         const QString& objectPath,
01831         QObject* parent = 0
01832     );
01833 
01840     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
01841 
01849     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01850 
01858     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01859 
01860 public Q_SLOTS:
01905     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
01906     {
01907         if (!invalidationReason().isEmpty()) {
01908             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
01909                 invalidationReason(),
01910                 invalidationMessage()
01911             ));
01912         }
01913 
01914 
01915         QList<QVariant> argumentList;
01916         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
01917         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
01918     }
01919 
01945     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
01946     {
01947         if (!invalidationReason().isEmpty()) {
01948             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
01949                 invalidationReason(),
01950                 invalidationMessage()
01951             ));
01952         }
01953 
01954 
01955         QList<QVariant> argumentList;
01956         argumentList << QVariant::fromValue(handles);
01957         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
01958     }
01959 
01960 Q_SIGNALS:
01983     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
01984 
01985 protected:
01986     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01987 };
01988 
01996 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCellularInterface : public Tp::AbstractInterface
01997 {
01998     Q_OBJECT
01999 
02000 public:
02007     static inline const char *staticInterfaceName()
02008     {
02009         return "org.freedesktop.Telepathy.Connection.Interface.Cellular";
02010     }
02011 
02019     ConnectionInterfaceCellularInterface(
02020         const QString& busName,
02021         const QString& objectPath,
02022         QObject* parent = 0
02023     );
02024 
02033     ConnectionInterfaceCellularInterface(
02034         const QDBusConnection& connection,
02035         const QString& busName,
02036         const QString& objectPath,
02037         QObject* parent = 0
02038     );
02039 
02046     ConnectionInterfaceCellularInterface(Tp::DBusProxy *proxy);
02047 
02055     explicit ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface);
02056 
02064     ConnectionInterfaceCellularInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02065 
02094     Q_PROPERTY(uint MessageValidityPeriod READ MessageValidityPeriod WRITE setMessageValidityPeriod)
02095 
02096     
02104     inline uint MessageValidityPeriod() const TELEPATHY_GNUC_DEPRECATED
02105     {
02106         return qvariant_cast<uint>(internalPropGet("MessageValidityPeriod"));
02107     }
02108 
02116     inline void setMessageValidityPeriod(uint newValue) TELEPATHY_GNUC_DEPRECATED
02117     {
02118         internalPropSet("MessageValidityPeriod", QVariant::fromValue(newValue));
02119     }
02120 
02153     Q_PROPERTY(bool OverrideMessageServiceCentre READ OverrideMessageServiceCentre WRITE setOverrideMessageServiceCentre)
02154 
02155     
02163     inline bool OverrideMessageServiceCentre() const TELEPATHY_GNUC_DEPRECATED
02164     {
02165         return qvariant_cast<bool>(internalPropGet("OverrideMessageServiceCentre"));
02166     }
02167 
02175     inline void setOverrideMessageServiceCentre(bool newValue) TELEPATHY_GNUC_DEPRECATED
02176     {
02177         internalPropSet("OverrideMessageServiceCentre", QVariant::fromValue(newValue));
02178     }
02179 
02206     Q_PROPERTY(QString MessageServiceCentre READ MessageServiceCentre WRITE setMessageServiceCentre)
02207 
02208     
02216     inline QString MessageServiceCentre() const TELEPATHY_GNUC_DEPRECATED
02217     {
02218         return qvariant_cast<QString>(internalPropGet("MessageServiceCentre"));
02219     }
02220 
02228     inline void setMessageServiceCentre(const QString& newValue) TELEPATHY_GNUC_DEPRECATED
02229     {
02230         internalPropSet("MessageServiceCentre", QVariant::fromValue(newValue));
02231     }
02232 
02240     Q_PROPERTY(QString IMSI READ IMSI)
02241 
02242     
02250     inline QString IMSI() const TELEPATHY_GNUC_DEPRECATED
02251     {
02252         return qvariant_cast<QString>(internalPropGet("IMSI"));
02253     }
02254 
02282     Q_PROPERTY(bool MessageReducedCharacterSet READ MessageReducedCharacterSet WRITE setMessageReducedCharacterSet)
02283 
02284     
02292     inline bool MessageReducedCharacterSet() const TELEPATHY_GNUC_DEPRECATED
02293     {
02294         return qvariant_cast<bool>(internalPropGet("MessageReducedCharacterSet"));
02295     }
02296 
02304     inline void setMessageReducedCharacterSet(bool newValue) TELEPATHY_GNUC_DEPRECATED
02305     {
02306         internalPropSet("MessageReducedCharacterSet", QVariant::fromValue(newValue));
02307     }
02308 
02309 Q_SIGNALS:
02325     void IMSIChanged(const QString& IMSI);
02326 
02327 protected:
02328     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02329 };
02330 
02338 class TELEPATHY_QT4_EXPORT ConnectionInterfaceClientTypesInterface : public Tp::AbstractInterface
02339 {
02340     Q_OBJECT
02341 
02342 public:
02349     static inline const char *staticInterfaceName()
02350     {
02351         return "org.freedesktop.Telepathy.Connection.Interface.ClientTypes";
02352     }
02353 
02361     ConnectionInterfaceClientTypesInterface(
02362         const QString& busName,
02363         const QString& objectPath,
02364         QObject* parent = 0
02365     );
02366 
02375     ConnectionInterfaceClientTypesInterface(
02376         const QDBusConnection& connection,
02377         const QString& busName,
02378         const QString& objectPath,
02379         QObject* parent = 0
02380     );
02381 
02388     ConnectionInterfaceClientTypesInterface(Tp::DBusProxy *proxy);
02389 
02397     explicit ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02398 
02406     ConnectionInterfaceClientTypesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02407 
02408 public Q_SLOTS:
02432     inline QDBusPendingReply<Tp::ContactClientTypes> GetClientTypes(const Tp::UIntList& contacts)
02433     {
02434         if (!invalidationReason().isEmpty()) {
02435             return QDBusPendingReply<Tp::ContactClientTypes>(QDBusMessage::createError(
02436                 invalidationReason(),
02437                 invalidationMessage()
02438             ));
02439         }
02440 
02441 
02442         QList<QVariant> argumentList;
02443         argumentList << QVariant::fromValue(contacts);
02444         return asyncCallWithArgumentList(QLatin1String("GetClientTypes"), argumentList);
02445     }
02446 
02466     inline QDBusPendingReply<QStringList> RequestClientTypes(uint contact)
02467     {
02468         if (!invalidationReason().isEmpty()) {
02469             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
02470                 invalidationReason(),
02471                 invalidationMessage()
02472             ));
02473         }
02474 
02475 
02476         QList<QVariant> argumentList;
02477         argumentList << QVariant::fromValue(contact);
02478         return asyncCallWithArgumentList(QLatin1String("RequestClientTypes"), argumentList);
02479     }
02480 
02481 Q_SIGNALS:
02496     void ClientTypesUpdated(uint contact, const QStringList& clientTypes);
02497 
02498 protected:
02499     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02500 };
02501 
02509 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
02510 {
02511     Q_OBJECT
02512 
02513 public:
02520     static inline const char *staticInterfaceName()
02521     {
02522         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
02523     }
02524 
02532     ConnectionInterfaceContactCapabilitiesInterface(
02533         const QString& busName,
02534         const QString& objectPath,
02535         QObject* parent = 0
02536     );
02537 
02546     ConnectionInterfaceContactCapabilitiesInterface(
02547         const QDBusConnection& connection,
02548         const QString& busName,
02549         const QString& objectPath,
02550         QObject* parent = 0
02551     );
02552 
02559     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
02560 
02568     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
02569 
02577     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02578 
02579 public Q_SLOTS:
02635     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
02636     {
02637         if (!invalidationReason().isEmpty()) {
02638             return QDBusPendingReply<>(QDBusMessage::createError(
02639                 invalidationReason(),
02640                 invalidationMessage()
02641             ));
02642         }
02643 
02644 
02645         QList<QVariant> argumentList;
02646         argumentList << QVariant::fromValue(handlerCapabilities);
02647         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
02648     }
02649 
02674     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
02675     {
02676         if (!invalidationReason().isEmpty()) {
02677             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
02678                 invalidationReason(),
02679                 invalidationMessage()
02680             ));
02681         }
02682 
02683 
02684         QList<QVariant> argumentList;
02685         argumentList << QVariant::fromValue(handles);
02686         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
02687     }
02688 
02689 Q_SIGNALS:
02706     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
02707 
02708 protected:
02709     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02710 };
02711 
02719 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactGroupsInterface : public Tp::AbstractInterface
02720 {
02721     Q_OBJECT
02722 
02723 public:
02730     static inline const char *staticInterfaceName()
02731     {
02732         return "org.freedesktop.Telepathy.Connection.Interface.ContactGroups";
02733     }
02734 
02742     ConnectionInterfaceContactGroupsInterface(
02743         const QString& busName,
02744         const QString& objectPath,
02745         QObject* parent = 0
02746     );
02747 
02756     ConnectionInterfaceContactGroupsInterface(
02757         const QDBusConnection& connection,
02758         const QString& busName,
02759         const QString& objectPath,
02760         QObject* parent = 0
02761     );
02762 
02769     ConnectionInterfaceContactGroupsInterface(Tp::DBusProxy *proxy);
02770 
02778     explicit ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02779 
02787     ConnectionInterfaceContactGroupsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02788 
02799     Q_PROPERTY(bool DisjointGroups READ DisjointGroups)
02800 
02801     
02809     inline bool DisjointGroups() const TELEPATHY_GNUC_DEPRECATED
02810     {
02811         return qvariant_cast<bool>(internalPropGet("DisjointGroups"));
02812     }
02813 
02822     Q_PROPERTY(uint GroupStorage READ GroupStorage)
02823 
02824     
02832     inline uint GroupStorage() const TELEPATHY_GNUC_DEPRECATED
02833     {
02834         return qvariant_cast<uint>(internalPropGet("GroupStorage"));
02835     }
02836 
02854     Q_PROPERTY(QStringList Groups READ Groups)
02855 
02856     
02864     inline QStringList Groups() const TELEPATHY_GNUC_DEPRECATED
02865     {
02866         return qvariant_cast<QStringList>(internalPropGet("Groups"));
02867     }
02868 
02869 public Q_SLOTS:
02911     inline QDBusPendingReply<> SetContactGroups(uint contact, const QStringList& groups)
02912     {
02913         if (!invalidationReason().isEmpty()) {
02914             return QDBusPendingReply<>(QDBusMessage::createError(
02915                 invalidationReason(),
02916                 invalidationMessage()
02917             ));
02918         }
02919 
02920 
02921         QList<QVariant> argumentList;
02922         argumentList << QVariant::fromValue(contact) << QVariant::fromValue(groups);
02923         return asyncCallWithArgumentList(QLatin1String("SetContactGroups"), argumentList);
02924     }
02925 
02966     inline QDBusPendingReply<> SetGroupMembers(const QString& group, const Tp::UIntList& members)
02967     {
02968         if (!invalidationReason().isEmpty()) {
02969             return QDBusPendingReply<>(QDBusMessage::createError(
02970                 invalidationReason(),
02971                 invalidationMessage()
02972             ));
02973         }
02974 
02975 
02976         QList<QVariant> argumentList;
02977         argumentList << QVariant::fromValue(group) << QVariant::fromValue(members);
02978         return asyncCallWithArgumentList(QLatin1String("SetGroupMembers"), argumentList);
02979     }
02980 
03014     inline QDBusPendingReply<> AddToGroup(const QString& group, const Tp::UIntList& members)
03015     {
03016         if (!invalidationReason().isEmpty()) {
03017             return QDBusPendingReply<>(QDBusMessage::createError(
03018                 invalidationReason(),
03019                 invalidationMessage()
03020             ));
03021         }
03022 
03023 
03024         QList<QVariant> argumentList;
03025         argumentList << QVariant::fromValue(group) << QVariant::fromValue(members);
03026         return asyncCallWithArgumentList(QLatin1String("AddToGroup"), argumentList);
03027     }
03028 
03061     inline QDBusPendingReply<> RemoveFromGroup(const QString& group, const Tp::UIntList& members)
03062     {
03063         if (!invalidationReason().isEmpty()) {
03064             return QDBusPendingReply<>(QDBusMessage::createError(
03065                 invalidationReason(),
03066                 invalidationMessage()
03067             ));
03068         }
03069 
03070 
03071         QList<QVariant> argumentList;
03072         argumentList << QVariant::fromValue(group) << QVariant::fromValue(members);
03073         return asyncCallWithArgumentList(QLatin1String("RemoveFromGroup"), argumentList);
03074     }
03075 
03097     inline QDBusPendingReply<> RemoveGroup(const QString& group)
03098     {
03099         if (!invalidationReason().isEmpty()) {
03100             return QDBusPendingReply<>(QDBusMessage::createError(
03101                 invalidationReason(),
03102                 invalidationMessage()
03103             ));
03104         }
03105 
03106 
03107         QList<QVariant> argumentList;
03108         argumentList << QVariant::fromValue(group);
03109         return asyncCallWithArgumentList(QLatin1String("RemoveGroup"), argumentList);
03110     }
03111 
03144     inline QDBusPendingReply<> RenameGroup(const QString& oldName, const QString& newName)
03145     {
03146         if (!invalidationReason().isEmpty()) {
03147             return QDBusPendingReply<>(QDBusMessage::createError(
03148                 invalidationReason(),
03149                 invalidationMessage()
03150             ));
03151         }
03152 
03153 
03154         QList<QVariant> argumentList;
03155         argumentList << QVariant::fromValue(oldName) << QVariant::fromValue(newName);
03156         return asyncCallWithArgumentList(QLatin1String("RenameGroup"), argumentList);
03157     }
03158 
03159 Q_SIGNALS:
03177     void GroupsChanged(const Tp::UIntList& contact, const QStringList& added, const QStringList& removed);
03178 
03189     void GroupsCreated(const QStringList& names);
03190 
03236     void GroupRenamed(const QString& oldName, const QString& newName);
03237 
03262     void GroupsRemoved(const QStringList& names);
03263 
03264 protected:
03265     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03266 };
03267 
03275 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
03276 {
03277     Q_OBJECT
03278 
03279 public:
03286     static inline const char *staticInterfaceName()
03287     {
03288         return "org.freedesktop.Telepathy.Connection.Interface.ContactInfo";
03289     }
03290 
03298     ConnectionInterfaceContactInfoInterface(
03299         const QString& busName,
03300         const QString& objectPath,
03301         QObject* parent = 0
03302     );
03303 
03312     ConnectionInterfaceContactInfoInterface(
03313         const QDBusConnection& connection,
03314         const QString& busName,
03315         const QString& objectPath,
03316         QObject* parent = 0
03317     );
03318 
03325     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
03326 
03334     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
03335 
03343     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03344 
03362     Q_PROPERTY(uint ContactInfoFlags READ ContactInfoFlags)
03363 
03364     
03372     inline uint ContactInfoFlags() const TELEPATHY_GNUC_DEPRECATED
03373     {
03374         return qvariant_cast<uint>(internalPropGet("ContactInfoFlags"));
03375     }
03376 
03428     Q_PROPERTY(Tp::FieldSpecs SupportedFields READ SupportedFields)
03429 
03430     
03438     inline Tp::FieldSpecs SupportedFields() const TELEPATHY_GNUC_DEPRECATED
03439     {
03440         return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
03441     }
03442 
03443 public Q_SLOTS:
03461     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
03462     {
03463         if (!invalidationReason().isEmpty()) {
03464             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
03465                 invalidationReason(),
03466                 invalidationMessage()
03467             ));
03468         }
03469 
03470 
03471         QList<QVariant> argumentList;
03472         argumentList << QVariant::fromValue(contacts);
03473         return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
03474     }
03475 
03490     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
03491     {
03492         if (!invalidationReason().isEmpty()) {
03493             return QDBusPendingReply<>(QDBusMessage::createError(
03494                 invalidationReason(),
03495                 invalidationMessage()
03496             ));
03497         }
03498 
03499 
03500         QList<QVariant> argumentList;
03501         argumentList << QVariant::fromValue(contacts);
03502         return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
03503     }
03504 
03521     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
03522     {
03523         if (!invalidationReason().isEmpty()) {
03524             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
03525                 invalidationReason(),
03526                 invalidationMessage()
03527             ));
03528         }
03529 
03530 
03531         QList<QVariant> argumentList;
03532         argumentList << QVariant::fromValue(contact);
03533         return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
03534     }
03535 
03548     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
03549     {
03550         if (!invalidationReason().isEmpty()) {
03551             return QDBusPendingReply<>(QDBusMessage::createError(
03552                 invalidationReason(),
03553                 invalidationMessage()
03554             ));
03555         }
03556 
03557 
03558         QList<QVariant> argumentList;
03559         argumentList << QVariant::fromValue(contactInfo);
03560         return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
03561     }
03562 
03563 Q_SIGNALS:
03578     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
03579 
03580 protected:
03581     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03582 };
03583 
03591 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactListInterface : public Tp::AbstractInterface
03592 {
03593     Q_OBJECT
03594 
03595 public:
03602     static inline const char *staticInterfaceName()
03603     {
03604         return "org.freedesktop.Telepathy.Connection.Interface.ContactList";
03605     }
03606 
03614     ConnectionInterfaceContactListInterface(
03615         const QString& busName,
03616         const QString& objectPath,
03617         QObject* parent = 0
03618     );
03619 
03628     ConnectionInterfaceContactListInterface(
03629         const QDBusConnection& connection,
03630         const QString& busName,
03631         const QString& objectPath,
03632         QObject* parent = 0
03633     );
03634 
03641     ConnectionInterfaceContactListInterface(Tp::DBusProxy *proxy);
03642 
03650     explicit ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface);
03651 
03659     ConnectionInterfaceContactListInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03660 
03667     Q_PROPERTY(uint ContactListState READ ContactListState)
03668 
03669     
03677     inline uint ContactListState() const TELEPATHY_GNUC_DEPRECATED
03678     {
03679         return qvariant_cast<uint>(internalPropGet("ContactListState"));
03680     }
03681 
03735     Q_PROPERTY(bool ContactListPersists READ ContactListPersists)
03736 
03737     
03745     inline bool ContactListPersists() const TELEPATHY_GNUC_DEPRECATED
03746     {
03747         return qvariant_cast<bool>(internalPropGet("ContactListPersists"));
03748     }
03749 
03772     Q_PROPERTY(bool CanChangeContactList READ CanChangeContactList)
03773 
03774     
03782     inline bool CanChangeContactList() const TELEPATHY_GNUC_DEPRECATED
03783     {
03784         return qvariant_cast<bool>(internalPropGet("CanChangeContactList"));
03785     }
03786 
03809     Q_PROPERTY(bool RequestUsesMessage READ RequestUsesMessage)
03810 
03811     
03819     inline bool RequestUsesMessage() const TELEPATHY_GNUC_DEPRECATED
03820     {
03821         return qvariant_cast<bool>(internalPropGet("RequestUsesMessage"));
03822     }
03823 
03824 public Q_SLOTS:
03880     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactListAttributes(const QStringList& interfaces, bool hold)
03881     {
03882         if (!invalidationReason().isEmpty()) {
03883             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
03884                 invalidationReason(),
03885                 invalidationMessage()
03886             ));
03887         }
03888 
03889 
03890         QList<QVariant> argumentList;
03891         argumentList << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
03892         return asyncCallWithArgumentList(QLatin1String("GetContactListAttributes"), argumentList);
03893     }
03894 
03982     inline QDBusPendingReply<> RequestSubscription(const Tp::UIntList& contacts, const QString& message)
03983     {
03984         if (!invalidationReason().isEmpty()) {
03985             return QDBusPendingReply<>(QDBusMessage::createError(
03986                 invalidationReason(),
03987                 invalidationMessage()
03988             ));
03989         }
03990 
03991 
03992         QList<QVariant> argumentList;
03993         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
03994         return asyncCallWithArgumentList(QLatin1String("RequestSubscription"), argumentList);
03995     }
03996 
04046     inline QDBusPendingReply<> AuthorizePublication(const Tp::UIntList& contacts)
04047     {
04048         if (!invalidationReason().isEmpty()) {
04049             return QDBusPendingReply<>(QDBusMessage::createError(
04050                 invalidationReason(),
04051                 invalidationMessage()
04052             ));
04053         }
04054 
04055 
04056         QList<QVariant> argumentList;
04057         argumentList << QVariant::fromValue(contacts);
04058         return asyncCallWithArgumentList(QLatin1String("AuthorizePublication"), argumentList);
04059     }
04060 
04101     inline QDBusPendingReply<> RemoveContacts(const Tp::UIntList& contacts)
04102     {
04103         if (!invalidationReason().isEmpty()) {
04104             return QDBusPendingReply<>(QDBusMessage::createError(
04105                 invalidationReason(),
04106                 invalidationMessage()
04107             ));
04108         }
04109 
04110 
04111         QList<QVariant> argumentList;
04112         argumentList << QVariant::fromValue(contacts);
04113         return asyncCallWithArgumentList(QLatin1String("RemoveContacts"), argumentList);
04114     }
04115 
04143     inline QDBusPendingReply<> Unsubscribe(const Tp::UIntList& contacts)
04144     {
04145         if (!invalidationReason().isEmpty()) {
04146             return QDBusPendingReply<>(QDBusMessage::createError(
04147                 invalidationReason(),
04148                 invalidationMessage()
04149             ));
04150         }
04151 
04152 
04153         QList<QVariant> argumentList;
04154         argumentList << QVariant::fromValue(contacts);
04155         return asyncCallWithArgumentList(QLatin1String("Unsubscribe"), argumentList);
04156     }
04157 
04185     inline QDBusPendingReply<> Unpublish(const Tp::UIntList& contacts)
04186     {
04187         if (!invalidationReason().isEmpty()) {
04188             return QDBusPendingReply<>(QDBusMessage::createError(
04189                 invalidationReason(),
04190                 invalidationMessage()
04191             ));
04192         }
04193 
04194 
04195         QList<QVariant> argumentList;
04196         argumentList << QVariant::fromValue(contacts);
04197         return asyncCallWithArgumentList(QLatin1String("Unpublish"), argumentList);
04198     }
04199 
04200 Q_SIGNALS:
04210     void ContactListStateChanged(uint contactListState);
04211 
04251     void ContactsChanged(const Tp::ContactSubscriptionMap& changes, const Tp::UIntList& removals);
04252 
04253 protected:
04254     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04255 };
04256 
04264 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
04265 {
04266     Q_OBJECT
04267 
04268 public:
04275     static inline const char *staticInterfaceName()
04276     {
04277         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
04278     }
04279 
04287     ConnectionInterfaceContactsInterface(
04288         const QString& busName,
04289         const QString& objectPath,
04290         QObject* parent = 0
04291     );
04292 
04301     ConnectionInterfaceContactsInterface(
04302         const QDBusConnection& connection,
04303         const QString& busName,
04304         const QString& objectPath,
04305         QObject* parent = 0
04306     );
04307 
04314     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
04315 
04323     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
04324 
04332     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04333 
04340     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
04341 
04342     
04350     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
04351     {
04352         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
04353     }
04354 
04355 public Q_SLOTS:
04421     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
04422     {
04423         if (!invalidationReason().isEmpty()) {
04424             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
04425                 invalidationReason(),
04426                 invalidationMessage()
04427             ));
04428         }
04429 
04430 
04431         QList<QVariant> argumentList;
04432         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
04433         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
04434     }
04435 
04436 protected:
04437     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04438 };
04439 
04447 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
04448 {
04449     Q_OBJECT
04450 
04451 public:
04458     static inline const char *staticInterfaceName()
04459     {
04460         return "org.freedesktop.Telepathy.Connection.Interface.Location";
04461     }
04462 
04470     ConnectionInterfaceLocationInterface(
04471         const QString& busName,
04472         const QString& objectPath,
04473         QObject* parent = 0
04474     );
04475 
04484     ConnectionInterfaceLocationInterface(
04485         const QDBusConnection& connection,
04486         const QString& busName,
04487         const QString& objectPath,
04488         QObject* parent = 0
04489     );
04490 
04497     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
04498 
04506     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
04507 
04515     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04516 
04522     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
04523 
04524     
04532     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
04533     {
04534         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
04535     }
04536 
04545     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
04546 
04547     
04555     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
04556     {
04557         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
04558     }
04559 
04567     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
04568     {
04569         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
04570     }
04571 
04579     Q_PROPERTY(uint SupportedLocationFeatures READ SupportedLocationFeatures)
04580 
04581     
04589     inline uint SupportedLocationFeatures() const TELEPATHY_GNUC_DEPRECATED
04590     {
04591         return qvariant_cast<uint>(internalPropGet("SupportedLocationFeatures"));
04592     }
04593 
04594 public Q_SLOTS:
04618     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
04619     {
04620         if (!invalidationReason().isEmpty()) {
04621             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
04622                 invalidationReason(),
04623                 invalidationMessage()
04624             ));
04625         }
04626 
04627 
04628         QList<QVariant> argumentList;
04629         argumentList << QVariant::fromValue(contacts);
04630         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
04631     }
04632 
04652     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
04653     {
04654         if (!invalidationReason().isEmpty()) {
04655             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
04656                 invalidationReason(),
04657                 invalidationMessage()
04658             ));
04659         }
04660 
04661 
04662         QList<QVariant> argumentList;
04663         argumentList << QVariant::fromValue(contact);
04664         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
04665     }
04666 
04683     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
04684     {
04685         if (!invalidationReason().isEmpty()) {
04686             return QDBusPendingReply<>(QDBusMessage::createError(
04687                 invalidationReason(),
04688                 invalidationMessage()
04689             ));
04690         }
04691 
04692 
04693         QList<QVariant> argumentList;
04694         argumentList << QVariant::fromValue(location);
04695         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
04696     }
04697 
04698 Q_SIGNALS:
04713     void LocationUpdated(uint contact, const QVariantMap& location);
04714 
04715 protected:
04716     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04717 };
04718 
04726 class TELEPATHY_QT4_EXPORT ConnectionInterfacePowerSavingInterface : public Tp::AbstractInterface
04727 {
04728     Q_OBJECT
04729 
04730 public:
04737     static inline const char *staticInterfaceName()
04738     {
04739         return "org.freedesktop.Telepathy.Connection.Interface.PowerSaving.DRAFT";
04740     }
04741 
04749     ConnectionInterfacePowerSavingInterface(
04750         const QString& busName,
04751         const QString& objectPath,
04752         QObject* parent = 0
04753     );
04754 
04763     ConnectionInterfacePowerSavingInterface(
04764         const QDBusConnection& connection,
04765         const QString& busName,
04766         const QString& objectPath,
04767         QObject* parent = 0
04768     );
04769 
04776     ConnectionInterfacePowerSavingInterface(Tp::DBusProxy *proxy);
04777 
04785     explicit ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface);
04786 
04794     ConnectionInterfacePowerSavingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04795 
04805     Q_PROPERTY(bool PowerSavingActive READ PowerSavingActive)
04806 
04807     
04815     inline bool PowerSavingActive() const TELEPATHY_GNUC_DEPRECATED
04816     {
04817         return qvariant_cast<bool>(internalPropGet("PowerSavingActive"));
04818     }
04819 
04820 public Q_SLOTS:
04847     inline QDBusPendingReply<> SetPowerSaving(bool activate)
04848     {
04849         if (!invalidationReason().isEmpty()) {
04850             return QDBusPendingReply<>(QDBusMessage::createError(
04851                 invalidationReason(),
04852                 invalidationMessage()
04853             ));
04854         }
04855 
04856 
04857         QList<QVariant> argumentList;
04858         argumentList << QVariant::fromValue(activate);
04859         return asyncCallWithArgumentList(QLatin1String("SetPowerSaving"), argumentList);
04860     }
04861 
04862 Q_SIGNALS:
04873     void PowerSavingChanged(bool active);
04874 
04875 protected:
04876     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04877 };
04878 
04886 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
04887 {
04888     Q_OBJECT
04889 
04890 public:
04897     static inline const char *staticInterfaceName()
04898     {
04899         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
04900     }
04901 
04909     ConnectionInterfacePresenceInterface(
04910         const QString& busName,
04911         const QString& objectPath,
04912         QObject* parent = 0
04913     );
04914 
04923     ConnectionInterfacePresenceInterface(
04924         const QDBusConnection& connection,
04925         const QString& busName,
04926         const QString& objectPath,
04927         QObject* parent = 0
04928     );
04929 
04936     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
04937 
04945     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
04946 
04954     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
04955 
04956 public Q_SLOTS:
04973     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
04974     {
04975         if (!invalidationReason().isEmpty()) {
04976             return QDBusPendingReply<>(QDBusMessage::createError(
04977                 invalidationReason(),
04978                 invalidationMessage()
04979             ));
04980         }
04981 
04982 
04983         QList<QVariant> argumentList;
04984         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
04985         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
04986     }
04987 
04996     inline QDBusPendingReply<> ClearStatus()
04997     {
04998         if (!invalidationReason().isEmpty()) {
04999             return QDBusPendingReply<>(QDBusMessage::createError(
05000                 invalidationReason(),
05001                 invalidationMessage()
05002             ));
05003         }
05004 
05005 
05006         return asyncCall(QLatin1String("ClearStatus"));
05007     }
05008 
05027     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
05028     {
05029         if (!invalidationReason().isEmpty()) {
05030             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
05031                 invalidationReason(),
05032                 invalidationMessage()
05033             ));
05034         }
05035 
05036 
05037         QList<QVariant> argumentList;
05038         argumentList << QVariant::fromValue(contacts);
05039         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
05040     }
05041 
05058     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
05059     {
05060         if (!invalidationReason().isEmpty()) {
05061             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
05062                 invalidationReason(),
05063                 invalidationMessage()
05064             ));
05065         }
05066 
05067 
05068         return asyncCall(QLatin1String("GetStatuses"));
05069     }
05070 
05084     inline QDBusPendingReply<> RemoveStatus(const QString& status)
05085     {
05086         if (!invalidationReason().isEmpty()) {
05087             return QDBusPendingReply<>(QDBusMessage::createError(
05088                 invalidationReason(),
05089                 invalidationMessage()
05090             ));
05091         }
05092 
05093 
05094         QList<QVariant> argumentList;
05095         argumentList << QVariant::fromValue(status);
05096         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
05097     }
05098 
05112     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
05113     {
05114         if (!invalidationReason().isEmpty()) {
05115             return QDBusPendingReply<>(QDBusMessage::createError(
05116                 invalidationReason(),
05117                 invalidationMessage()
05118             ));
05119         }
05120 
05121 
05122         QList<QVariant> argumentList;
05123         argumentList << QVariant::fromValue(contacts);
05124         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
05125     }
05126 
05137     inline QDBusPendingReply<> SetLastActivityTime(uint time)
05138     {
05139         if (!invalidationReason().isEmpty()) {
05140             return QDBusPendingReply<>(QDBusMessage::createError(
05141                 invalidationReason(),
05142                 invalidationMessage()
05143             ));
05144         }
05145 
05146 
05147         QList<QVariant> argumentList;
05148         argumentList << QVariant::fromValue(time);
05149         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
05150     }
05151 
05182     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
05183     {
05184         if (!invalidationReason().isEmpty()) {
05185             return QDBusPendingReply<>(QDBusMessage::createError(
05186                 invalidationReason(),
05187                 invalidationMessage()
05188             ));
05189         }
05190 
05191 
05192         QList<QVariant> argumentList;
05193         argumentList << QVariant::fromValue(statuses);
05194         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
05195     }
05196 
05197 Q_SIGNALS:
05214     void PresenceUpdate(const Tp::ContactPresences& presence);
05215 
05216 protected:
05217     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05218 };
05219 
05227 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
05228 {
05229     Q_OBJECT
05230 
05231 public:
05238     static inline const char *staticInterfaceName()
05239     {
05240         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
05241     }
05242 
05250     ConnectionInterfaceRequestsInterface(
05251         const QString& busName,
05252         const QString& objectPath,
05253         QObject* parent = 0
05254     );
05255 
05264     ConnectionInterfaceRequestsInterface(
05265         const QDBusConnection& connection,
05266         const QString& busName,
05267         const QString& objectPath,
05268         QObject* parent = 0
05269     );
05270 
05277     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
05278 
05286     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
05287 
05295     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05296 
05303     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
05304 
05305     
05313     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
05314     {
05315         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
05316     }
05317 
05341     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
05342 
05343     
05351     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
05352     {
05353         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
05354     }
05355 
05356 public Q_SLOTS:
05425     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
05426     {
05427         if (!invalidationReason().isEmpty()) {
05428             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
05429                 invalidationReason(),
05430                 invalidationMessage()
05431             ));
05432         }
05433 
05434 
05435         QList<QVariant> argumentList;
05436         argumentList << QVariant::fromValue(request);
05437         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
05438     }
05439 
05491     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
05492     {
05493         if (!invalidationReason().isEmpty()) {
05494             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
05495                 invalidationReason(),
05496                 invalidationMessage()
05497             ));
05498         }
05499 
05500 
05501         QList<QVariant> argumentList;
05502         argumentList << QVariant::fromValue(request);
05503         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
05504     }
05505 
05506 Q_SIGNALS:
05548     void NewChannels(const Tp::ChannelDetailsList& channels);
05549 
05562     void ChannelClosed(const QDBusObjectPath& removed);
05563 
05564 protected:
05565     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05566 };
05567 
05575 class TELEPATHY_QT4_EXPORT ConnectionInterfaceServicePointInterface : public Tp::AbstractInterface
05576 {
05577     Q_OBJECT
05578 
05579 public:
05586     static inline const char *staticInterfaceName()
05587     {
05588         return "org.freedesktop.Telepathy.Connection.Interface.ServicePoint";
05589     }
05590 
05598     ConnectionInterfaceServicePointInterface(
05599         const QString& busName,
05600         const QString& objectPath,
05601         QObject* parent = 0
05602     );
05603 
05612     ConnectionInterfaceServicePointInterface(
05613         const QDBusConnection& connection,
05614         const QString& busName,
05615         const QString& objectPath,
05616         QObject* parent = 0
05617     );
05618 
05625     ConnectionInterfaceServicePointInterface(Tp::DBusProxy *proxy);
05626 
05634     explicit ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface);
05635 
05643     ConnectionInterfaceServicePointInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05644 
05650     Q_PROPERTY(Tp::ServicePointInfoList KnownServicePoints READ KnownServicePoints)
05651 
05652     
05660     inline Tp::ServicePointInfoList KnownServicePoints() const TELEPATHY_GNUC_DEPRECATED
05661     {
05662         return qvariant_cast<Tp::ServicePointInfoList>(internalPropGet("KnownServicePoints"));
05663     }
05664 
05665 Q_SIGNALS:
05677     void ServicePointsChanged(const Tp::ServicePointInfoList& servicePoints);
05678 
05679 protected:
05680     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05681 };
05682 
05690 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
05691 {
05692     Q_OBJECT
05693 
05694 public:
05701     static inline const char *staticInterfaceName()
05702     {
05703         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
05704     }
05705 
05713     ConnectionInterfaceSimplePresenceInterface(
05714         const QString& busName,
05715         const QString& objectPath,
05716         QObject* parent = 0
05717     );
05718 
05727     ConnectionInterfaceSimplePresenceInterface(
05728         const QDBusConnection& connection,
05729         const QString& busName,
05730         const QString& objectPath,
05731         QObject* parent = 0
05732     );
05733 
05740     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
05741 
05749     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
05750 
05758     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
05759 
05795     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
05796 
05797     
05805     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
05806     {
05807         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
05808     }
05809 
05810 public Q_SLOTS:
05865     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
05866     {
05867         if (!invalidationReason().isEmpty()) {
05868             return QDBusPendingReply<>(QDBusMessage::createError(
05869                 invalidationReason(),
05870                 invalidationMessage()
05871             ));
05872         }
05873 
05874 
05875         QList<QVariant> argumentList;
05876         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
05877         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
05878     }
05879 
05904     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
05905     {
05906         if (!invalidationReason().isEmpty()) {
05907             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
05908                 invalidationReason(),
05909                 invalidationMessage()
05910             ));
05911         }
05912 
05913 
05914         QList<QVariant> argumentList;
05915         argumentList << QVariant::fromValue(contacts);
05916         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
05917     }
05918 
05919 Q_SIGNALS:
05932     void PresencesChanged(const Tp::SimpleContactPresences& presence);
05933 
05934 protected:
05935     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05936 };
05937 }
05938 }
05939 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
05940 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
05941 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAnonymityInterface*)
05942 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
05943 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
05944 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
05945 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCellularInterface*)
05946 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceClientTypesInterface*)
05947 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
05948 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactGroupsInterface*)
05949 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
05950 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactListInterface*)
05951 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
05952 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
05953 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePowerSavingInterface*)
05954 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
05955 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
05956 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceServicePointInterface*)
05957 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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