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

cli-connection.h

00001 /*
00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
00003  *
00004  * This file can be distributed under the same terms as the specification from
00005  * which it was generated.
00006  */
00007 
00008 #ifndef IN_TELEPATHY_QT4_HEADER
00009 #error IN_TELEPATHY_QT4_HEADER
00010 #endif
00011 
00012 #include <TelepathyQt4/Types>
00013 
00014 #include <QtGlobal>
00015 
00016 #include <QString>
00017 #include <QObject>
00018 #include <QVariant>
00019 
00020 #include <QDBusPendingReply>
00021 
00022 #include <TelepathyQt4/AbstractInterface>
00023 #include <TelepathyQt4/DBusProxy>
00024 #include <TelepathyQt4/Global>
00025 
00026 // basically the same as GLib's G_GNUC_DEPRECATED
00027 #ifndef TELEPATHY_GNUC_DEPRECATED
00028 #   if defined(Q_CC_GNUC) && __GNUC__ >= 4
00029 #       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
00030 #   else
00031 #       define TELEPATHY_GNUC_DEPRECATED
00032 #   endif
00033 #endif
00034 namespace Tp
00035 {
00036 namespace Client
00037 {
00038 
00046 class TELEPATHY_QT4_EXPORT ConnectionInterface : public Tp::AbstractInterface
00047 {
00048     Q_OBJECT
00049 
00050 public:
00057     static inline const char *staticInterfaceName()
00058     {
00059         return "org.freedesktop.Telepathy.Connection";
00060     }
00061 
00069     ConnectionInterface(
00070         const QString& busName,
00071         const QString& objectPath,
00072         QObject* parent = 0
00073     );
00074 
00083     ConnectionInterface(
00084         const QDBusConnection& connection,
00085         const QString& busName,
00086         const QString& objectPath,
00087         QObject* parent = 0
00088     );
00089 
00096     ConnectionInterface(Tp::DBusProxy *proxy);
00097 
00123     Q_PROPERTY(QStringList Interfaces READ Interfaces)
00124 
00125     
00133     inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
00134     {
00135         return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
00136     }
00137 
00147     Q_PROPERTY(uint SelfHandle READ SelfHandle)
00148 
00149     
00157     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
00158     {
00159         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
00160     }
00161 
00174     Q_PROPERTY(uint Status READ Status)
00175 
00176     
00184     inline uint Status() const TELEPATHY_GNUC_DEPRECATED
00185     {
00186         return qvariant_cast<uint>(internalPropGet("Status"));
00187     }
00188 
00189 public Q_SLOTS:
00200     inline QDBusPendingReply<> Connect()
00201     {
00202         if (!invalidationReason().isEmpty()) {
00203             return QDBusPendingReply<>(QDBusMessage::createError(
00204                 invalidationReason(),
00205                 invalidationMessage()
00206             ));
00207         }
00208 
00209 
00210         return asyncCall(QLatin1String("Connect"));
00211     }
00212 
00220     inline QDBusPendingReply<> Disconnect()
00221     {
00222         if (!invalidationReason().isEmpty()) {
00223             return QDBusPendingReply<>(QDBusMessage::createError(
00224                 invalidationReason(),
00225                 invalidationMessage()
00226             ));
00227         }
00228 
00229 
00230         return asyncCall(QLatin1String("Disconnect"));
00231     }
00232 
00244     inline QDBusPendingReply<QStringList> GetInterfaces()
00245     {
00246         if (!invalidationReason().isEmpty()) {
00247             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00248                 invalidationReason(),
00249                 invalidationMessage()
00250             ));
00251         }
00252 
00253 
00254         return asyncCall(QLatin1String("GetInterfaces"));
00255     }
00256 
00266     inline QDBusPendingReply<QString> GetProtocol()
00267     {
00268         if (!invalidationReason().isEmpty()) {
00269             return QDBusPendingReply<QString>(QDBusMessage::createError(
00270                 invalidationReason(),
00271                 invalidationMessage()
00272             ));
00273         }
00274 
00275 
00276         return asyncCall(QLatin1String("GetProtocol"));
00277     }
00278 
00289     inline QDBusPendingReply<uint> GetSelfHandle()
00290     {
00291         if (!invalidationReason().isEmpty()) {
00292             return QDBusPendingReply<uint>(QDBusMessage::createError(
00293                 invalidationReason(),
00294                 invalidationMessage()
00295             ));
00296         }
00297 
00298 
00299         return asyncCall(QLatin1String("GetSelfHandle"));
00300     }
00301 
00311     inline QDBusPendingReply<uint> GetStatus()
00312     {
00313         if (!invalidationReason().isEmpty()) {
00314             return QDBusPendingReply<uint>(QDBusMessage::createError(
00315                 invalidationReason(),
00316                 invalidationMessage()
00317             ));
00318         }
00319 
00320 
00321         return asyncCall(QLatin1String("GetStatus"));
00322     }
00323 
00353     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles)
00354     {
00355         if (!invalidationReason().isEmpty()) {
00356             return QDBusPendingReply<>(QDBusMessage::createError(
00357                 invalidationReason(),
00358                 invalidationMessage()
00359             ));
00360         }
00361 
00362 
00363         QList<QVariant> argumentList;
00364         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00365         return asyncCallWithArgumentList(QLatin1String("HoldHandles"), argumentList);
00366     }
00367 
00386     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles)
00387     {
00388         if (!invalidationReason().isEmpty()) {
00389             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00390                 invalidationReason(),
00391                 invalidationMessage()
00392             ));
00393         }
00394 
00395 
00396         QList<QVariant> argumentList;
00397         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00398         return asyncCallWithArgumentList(QLatin1String("InspectHandles"), argumentList);
00399     }
00400 
00410     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels()
00411     {
00412         if (!invalidationReason().isEmpty()) {
00413             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00414                 invalidationReason(),
00415                 invalidationMessage()
00416             ));
00417         }
00418 
00419 
00420         return asyncCall(QLatin1String("ListChannels"));
00421     }
00422 
00439     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles)
00440     {
00441         if (!invalidationReason().isEmpty()) {
00442             return QDBusPendingReply<>(QDBusMessage::createError(
00443                 invalidationReason(),
00444                 invalidationMessage()
00445             ));
00446         }
00447 
00448 
00449         QList<QVariant> argumentList;
00450         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00451         return asyncCallWithArgumentList(QLatin1String("ReleaseHandles"), argumentList);
00452     }
00453 
00526     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler)
00527     {
00528         if (!invalidationReason().isEmpty()) {
00529             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00530                 invalidationReason(),
00531                 invalidationMessage()
00532             ));
00533         }
00534 
00535 
00536         QList<QVariant> argumentList;
00537         argumentList << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00538         return asyncCallWithArgumentList(QLatin1String("RequestChannel"), argumentList);
00539     }
00540 
00567     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers)
00568     {
00569         if (!invalidationReason().isEmpty()) {
00570             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00571                 invalidationReason(),
00572                 invalidationMessage()
00573             ));
00574         }
00575 
00576 
00577         QList<QVariant> argumentList;
00578         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
00579         return asyncCallWithArgumentList(QLatin1String("RequestHandles"), argumentList);
00580     }
00581 
00582 Q_SIGNALS:
00594     void SelfHandleChanged(uint selfHandle);
00595 
00637     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00638 
00702     void ConnectionError(const QString& error, const QVariantMap& details);
00703 
00720     void StatusChanged(uint status, uint reason);
00721 
00722 protected:
00723     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00724 };
00725 
00733 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00734 {
00735     Q_OBJECT
00736 
00737 public:
00744     static inline const char *staticInterfaceName()
00745     {
00746         return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
00747     }
00748 
00756     ConnectionInterfaceAliasingInterface(
00757         const QString& busName,
00758         const QString& objectPath,
00759         QObject* parent = 0
00760     );
00761 
00770     ConnectionInterfaceAliasingInterface(
00771         const QDBusConnection& connection,
00772         const QString& busName,
00773         const QString& objectPath,
00774         QObject* parent = 0
00775     );
00776 
00783     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
00784 
00792     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
00793 
00801     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00802 
00803 public Q_SLOTS:
00814     inline QDBusPendingReply<uint> GetAliasFlags()
00815     {
00816         if (!invalidationReason().isEmpty()) {
00817             return QDBusPendingReply<uint>(QDBusMessage::createError(
00818                 invalidationReason(),
00819                 invalidationMessage()
00820             ));
00821         }
00822 
00823 
00824         return asyncCall(QLatin1String("GetAliasFlags"));
00825     }
00826 
00840     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
00841     {
00842         if (!invalidationReason().isEmpty()) {
00843             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00844                 invalidationReason(),
00845                 invalidationMessage()
00846             ));
00847         }
00848 
00849 
00850         QList<QVariant> argumentList;
00851         argumentList << QVariant::fromValue(contacts);
00852         return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
00853     }
00854 
00872     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
00873     {
00874         if (!invalidationReason().isEmpty()) {
00875             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
00876                 invalidationReason(),
00877                 invalidationMessage()
00878             ));
00879         }
00880 
00881 
00882         QList<QVariant> argumentList;
00883         argumentList << QVariant::fromValue(contacts);
00884         return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
00885     }
00886 
00901     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
00902     {
00903         if (!invalidationReason().isEmpty()) {
00904             return QDBusPendingReply<>(QDBusMessage::createError(
00905                 invalidationReason(),
00906                 invalidationMessage()
00907             ));
00908         }
00909 
00910 
00911         QList<QVariant> argumentList;
00912         argumentList << QVariant::fromValue(aliases);
00913         return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
00914     }
00915 
00916 Q_SIGNALS:
00931     void AliasesChanged(const Tp::AliasPairList& aliases);
00932 
00933 protected:
00934     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00935 };
00936 
00944 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
00945 {
00946     Q_OBJECT
00947 
00948 public:
00955     static inline const char *staticInterfaceName()
00956     {
00957         return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
00958     }
00959 
00967     ConnectionInterfaceAvatarsInterface(
00968         const QString& busName,
00969         const QString& objectPath,
00970         QObject* parent = 0
00971     );
00972 
00981     ConnectionInterfaceAvatarsInterface(
00982         const QDBusConnection& connection,
00983         const QString& busName,
00984         const QString& objectPath,
00985         QObject* parent = 0
00986     );
00987 
00994     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
00995 
01003     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01004 
01012     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01013 
01021     Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
01022 
01023     
01031     inline QStringList SupportedAvatarMIMETypes() const TELEPATHY_GNUC_DEPRECATED
01032     {
01033         return qvariant_cast<QStringList>(internalPropGet("SupportedAvatarMIMETypes"));
01034     }
01035 
01043     Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
01044 
01045     
01053     inline uint MinimumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01054     {
01055         return qvariant_cast<uint>(internalPropGet("MinimumAvatarHeight"));
01056     }
01057 
01065     Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
01066 
01067     
01075     inline uint MinimumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01076     {
01077         return qvariant_cast<uint>(internalPropGet("MinimumAvatarWidth"));
01078     }
01079 
01090     Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
01091 
01092     
01100     inline uint RecommendedAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01101     {
01102         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarHeight"));
01103     }
01104 
01113     Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
01114 
01115     
01123     inline uint RecommendedAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01124     {
01125         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarWidth"));
01126     }
01127 
01135     Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
01136 
01137     
01145     inline uint MaximumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01146     {
01147         return qvariant_cast<uint>(internalPropGet("MaximumAvatarHeight"));
01148     }
01149 
01157     Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
01158 
01159     
01167     inline uint MaximumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01168     {
01169         return qvariant_cast<uint>(internalPropGet("MaximumAvatarWidth"));
01170     }
01171 
01179     Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
01180 
01181     
01189     inline uint MaximumAvatarBytes() const TELEPATHY_GNUC_DEPRECATED
01190     {
01191         return qvariant_cast<uint>(internalPropGet("MaximumAvatarBytes"));
01192     }
01193 
01194 public Q_SLOTS:
01224     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
01225     {
01226         if (!invalidationReason().isEmpty()) {
01227             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01228                 invalidationReason(),
01229                 invalidationMessage()
01230             ));
01231         }
01232 
01233 
01234         return asyncCall(QLatin1String("GetAvatarRequirements"));
01235     }
01236 
01253     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
01254     {
01255         if (!invalidationReason().isEmpty()) {
01256             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01257                 invalidationReason(),
01258                 invalidationMessage()
01259             ));
01260         }
01261 
01262 
01263         QList<QVariant> argumentList;
01264         argumentList << QVariant::fromValue(contacts);
01265         return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
01266     }
01267 
01290     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
01291     {
01292         if (!invalidationReason().isEmpty()) {
01293             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01294                 invalidationReason(),
01295                 invalidationMessage()
01296             ));
01297         }
01298 
01299 
01300         QList<QVariant> argumentList;
01301         argumentList << QVariant::fromValue(contacts);
01302         return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
01303     }
01304 
01324     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
01325     {
01326         if (!invalidationReason().isEmpty()) {
01327             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01328                 invalidationReason(),
01329                 invalidationMessage()
01330             ));
01331         }
01332 
01333 
01334         QList<QVariant> argumentList;
01335         argumentList << QVariant::fromValue(contact);
01336         return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
01337     }
01338 
01352     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
01353     {
01354         if (!invalidationReason().isEmpty()) {
01355             return QDBusPendingReply<>(QDBusMessage::createError(
01356                 invalidationReason(),
01357                 invalidationMessage()
01358             ));
01359         }
01360 
01361 
01362         QList<QVariant> argumentList;
01363         argumentList << QVariant::fromValue(contacts);
01364         return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
01365     }
01366 
01385     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
01386     {
01387         if (!invalidationReason().isEmpty()) {
01388             return QDBusPendingReply<QString>(QDBusMessage::createError(
01389                 invalidationReason(),
01390                 invalidationMessage()
01391             ));
01392         }
01393 
01394 
01395         QList<QVariant> argumentList;
01396         argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01397         return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
01398     }
01399 
01405     inline QDBusPendingReply<> ClearAvatar()
01406     {
01407         if (!invalidationReason().isEmpty()) {
01408             return QDBusPendingReply<>(QDBusMessage::createError(
01409                 invalidationReason(),
01410                 invalidationMessage()
01411             ));
01412         }
01413 
01414 
01415         return asyncCall(QLatin1String("ClearAvatar"));
01416     }
01417 
01418 Q_SIGNALS:
01435     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01436 
01459     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01460 
01461 protected:
01462     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01463 };
01464 
01472 class TELEPATHY_QT4_EXPORT ConnectionInterfaceBalanceInterface : public Tp::AbstractInterface
01473 {
01474     Q_OBJECT
01475 
01476 public:
01483     static inline const char *staticInterfaceName()
01484     {
01485         return "org.freedesktop.Telepathy.Connection.Interface.Balance";
01486     }
01487 
01495     ConnectionInterfaceBalanceInterface(
01496         const QString& busName,
01497         const QString& objectPath,
01498         QObject* parent = 0
01499     );
01500 
01509     ConnectionInterfaceBalanceInterface(
01510         const QDBusConnection& connection,
01511         const QString& busName,
01512         const QString& objectPath,
01513         QObject* parent = 0
01514     );
01515 
01522     ConnectionInterfaceBalanceInterface(Tp::DBusProxy *proxy);
01523 
01531     explicit ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01532 
01540     ConnectionInterfaceBalanceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01541 
01553     Q_PROPERTY(Tp::CurrencyAmount AccountBalance READ AccountBalance)
01554 
01555     
01563     inline Tp::CurrencyAmount AccountBalance() const TELEPATHY_GNUC_DEPRECATED
01564     {
01565         return qvariant_cast<Tp::CurrencyAmount>(internalPropGet("AccountBalance"));
01566     }
01567 
01568 Q_SIGNALS:
01579     void BalanceChanged(const Tp::CurrencyAmount& balance);
01580 
01581 protected:
01582     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01583 };
01584 
01592 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
01593 {
01594     Q_OBJECT
01595 
01596 public:
01603     static inline const char *staticInterfaceName()
01604     {
01605         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
01606     }
01607 
01615     ConnectionInterfaceCapabilitiesInterface(
01616         const QString& busName,
01617         const QString& objectPath,
01618         QObject* parent = 0
01619     );
01620 
01629     ConnectionInterfaceCapabilitiesInterface(
01630         const QDBusConnection& connection,
01631         const QString& busName,
01632         const QString& objectPath,
01633         QObject* parent = 0
01634     );
01635 
01642     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
01643 
01651     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01652 
01660     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01661 
01662 public Q_SLOTS:
01707     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
01708     {
01709         if (!invalidationReason().isEmpty()) {
01710             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
01711                 invalidationReason(),
01712                 invalidationMessage()
01713             ));
01714         }
01715 
01716 
01717         QList<QVariant> argumentList;
01718         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
01719         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
01720     }
01721 
01747     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
01748     {
01749         if (!invalidationReason().isEmpty()) {
01750             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
01751                 invalidationReason(),
01752                 invalidationMessage()
01753             ));
01754         }
01755 
01756 
01757         QList<QVariant> argumentList;
01758         argumentList << QVariant::fromValue(handles);
01759         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
01760     }
01761 
01762 Q_SIGNALS:
01785     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
01786 
01787 protected:
01788     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01789 };
01790 
01798 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
01799 {
01800     Q_OBJECT
01801 
01802 public:
01809     static inline const char *staticInterfaceName()
01810     {
01811         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
01812     }
01813 
01821     ConnectionInterfaceContactCapabilitiesInterface(
01822         const QString& busName,
01823         const QString& objectPath,
01824         QObject* parent = 0
01825     );
01826 
01835     ConnectionInterfaceContactCapabilitiesInterface(
01836         const QDBusConnection& connection,
01837         const QString& busName,
01838         const QString& objectPath,
01839         QObject* parent = 0
01840     );
01841 
01848     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
01849 
01857     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01858 
01866     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01867 
01868 public Q_SLOTS:
01924     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
01925     {
01926         if (!invalidationReason().isEmpty()) {
01927             return QDBusPendingReply<>(QDBusMessage::createError(
01928                 invalidationReason(),
01929                 invalidationMessage()
01930             ));
01931         }
01932 
01933 
01934         QList<QVariant> argumentList;
01935         argumentList << QVariant::fromValue(handlerCapabilities);
01936         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
01937     }
01938 
01963     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
01964     {
01965         if (!invalidationReason().isEmpty()) {
01966             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
01967                 invalidationReason(),
01968                 invalidationMessage()
01969             ));
01970         }
01971 
01972 
01973         QList<QVariant> argumentList;
01974         argumentList << QVariant::fromValue(handles);
01975         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
01976     }
01977 
01978 Q_SIGNALS:
01995     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
01996 
01997 protected:
01998     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01999 };
02000 
02008 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
02009 {
02010     Q_OBJECT
02011 
02012 public:
02019     static inline const char *staticInterfaceName()
02020     {
02021         return "org.freedesktop.Telepathy.Connection.Interface.ContactInfo";
02022     }
02023 
02031     ConnectionInterfaceContactInfoInterface(
02032         const QString& busName,
02033         const QString& objectPath,
02034         QObject* parent = 0
02035     );
02036 
02045     ConnectionInterfaceContactInfoInterface(
02046         const QDBusConnection& connection,
02047         const QString& busName,
02048         const QString& objectPath,
02049         QObject* parent = 0
02050     );
02051 
02058     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
02059 
02067     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
02068 
02076     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02077 
02095     Q_PROPERTY(uint ContactInfoFlags READ ContactInfoFlags)
02096 
02097     
02105     inline uint ContactInfoFlags() const TELEPATHY_GNUC_DEPRECATED
02106     {
02107         return qvariant_cast<uint>(internalPropGet("ContactInfoFlags"));
02108     }
02109 
02161     Q_PROPERTY(Tp::FieldSpecs SupportedFields READ SupportedFields)
02162 
02163     
02171     inline Tp::FieldSpecs SupportedFields() const TELEPATHY_GNUC_DEPRECATED
02172     {
02173         return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
02174     }
02175 
02176 public Q_SLOTS:
02194     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
02195     {
02196         if (!invalidationReason().isEmpty()) {
02197             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
02198                 invalidationReason(),
02199                 invalidationMessage()
02200             ));
02201         }
02202 
02203 
02204         QList<QVariant> argumentList;
02205         argumentList << QVariant::fromValue(contacts);
02206         return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
02207     }
02208 
02223     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
02224     {
02225         if (!invalidationReason().isEmpty()) {
02226             return QDBusPendingReply<>(QDBusMessage::createError(
02227                 invalidationReason(),
02228                 invalidationMessage()
02229             ));
02230         }
02231 
02232 
02233         QList<QVariant> argumentList;
02234         argumentList << QVariant::fromValue(contacts);
02235         return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
02236     }
02237 
02254     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
02255     {
02256         if (!invalidationReason().isEmpty()) {
02257             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
02258                 invalidationReason(),
02259                 invalidationMessage()
02260             ));
02261         }
02262 
02263 
02264         QList<QVariant> argumentList;
02265         argumentList << QVariant::fromValue(contact);
02266         return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
02267     }
02268 
02281     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
02282     {
02283         if (!invalidationReason().isEmpty()) {
02284             return QDBusPendingReply<>(QDBusMessage::createError(
02285                 invalidationReason(),
02286                 invalidationMessage()
02287             ));
02288         }
02289 
02290 
02291         QList<QVariant> argumentList;
02292         argumentList << QVariant::fromValue(contactInfo);
02293         return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
02294     }
02295 
02296 Q_SIGNALS:
02311     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
02312 
02313 protected:
02314     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02315 };
02316 
02324 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
02325 {
02326     Q_OBJECT
02327 
02328 public:
02335     static inline const char *staticInterfaceName()
02336     {
02337         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
02338     }
02339 
02347     ConnectionInterfaceContactsInterface(
02348         const QString& busName,
02349         const QString& objectPath,
02350         QObject* parent = 0
02351     );
02352 
02361     ConnectionInterfaceContactsInterface(
02362         const QDBusConnection& connection,
02363         const QString& busName,
02364         const QString& objectPath,
02365         QObject* parent = 0
02366     );
02367 
02374     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
02375 
02383     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02384 
02392     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02393 
02400     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
02401 
02402     
02410     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
02411     {
02412         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
02413     }
02414 
02415 public Q_SLOTS:
02481     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
02482     {
02483         if (!invalidationReason().isEmpty()) {
02484             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
02485                 invalidationReason(),
02486                 invalidationMessage()
02487             ));
02488         }
02489 
02490 
02491         QList<QVariant> argumentList;
02492         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
02493         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
02494     }
02495 
02496 protected:
02497     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02498 };
02499 
02507 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
02508 {
02509     Q_OBJECT
02510 
02511 public:
02518     static inline const char *staticInterfaceName()
02519     {
02520         return "org.freedesktop.Telepathy.Connection.Interface.Location";
02521     }
02522 
02530     ConnectionInterfaceLocationInterface(
02531         const QString& busName,
02532         const QString& objectPath,
02533         QObject* parent = 0
02534     );
02535 
02544     ConnectionInterfaceLocationInterface(
02545         const QDBusConnection& connection,
02546         const QString& busName,
02547         const QString& objectPath,
02548         QObject* parent = 0
02549     );
02550 
02557     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
02558 
02566     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
02567 
02575     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02576 
02582     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
02583 
02584     
02592     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
02593     {
02594         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
02595     }
02596 
02605     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
02606 
02607     
02615     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
02616     {
02617         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
02618     }
02619 
02627     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
02628     {
02629         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
02630     }
02631 
02632 public Q_SLOTS:
02656     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
02657     {
02658         if (!invalidationReason().isEmpty()) {
02659             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
02660                 invalidationReason(),
02661                 invalidationMessage()
02662             ));
02663         }
02664 
02665 
02666         QList<QVariant> argumentList;
02667         argumentList << QVariant::fromValue(contacts);
02668         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
02669     }
02670 
02690     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
02691     {
02692         if (!invalidationReason().isEmpty()) {
02693             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
02694                 invalidationReason(),
02695                 invalidationMessage()
02696             ));
02697         }
02698 
02699 
02700         QList<QVariant> argumentList;
02701         argumentList << QVariant::fromValue(contact);
02702         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
02703     }
02704 
02721     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
02722     {
02723         if (!invalidationReason().isEmpty()) {
02724             return QDBusPendingReply<>(QDBusMessage::createError(
02725                 invalidationReason(),
02726                 invalidationMessage()
02727             ));
02728         }
02729 
02730 
02731         QList<QVariant> argumentList;
02732         argumentList << QVariant::fromValue(location);
02733         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
02734     }
02735 
02736 Q_SIGNALS:
02751     void LocationUpdated(uint contact, const QVariantMap& location);
02752 
02753 protected:
02754     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02755 };
02756 
02764 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
02765 {
02766     Q_OBJECT
02767 
02768 public:
02775     static inline const char *staticInterfaceName()
02776     {
02777         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
02778     }
02779 
02787     ConnectionInterfacePresenceInterface(
02788         const QString& busName,
02789         const QString& objectPath,
02790         QObject* parent = 0
02791     );
02792 
02801     ConnectionInterfacePresenceInterface(
02802         const QDBusConnection& connection,
02803         const QString& busName,
02804         const QString& objectPath,
02805         QObject* parent = 0
02806     );
02807 
02814     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
02815 
02823     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
02824 
02832     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02833 
02834 public Q_SLOTS:
02851     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
02852     {
02853         if (!invalidationReason().isEmpty()) {
02854             return QDBusPendingReply<>(QDBusMessage::createError(
02855                 invalidationReason(),
02856                 invalidationMessage()
02857             ));
02858         }
02859 
02860 
02861         QList<QVariant> argumentList;
02862         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
02863         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
02864     }
02865 
02874     inline QDBusPendingReply<> ClearStatus()
02875     {
02876         if (!invalidationReason().isEmpty()) {
02877             return QDBusPendingReply<>(QDBusMessage::createError(
02878                 invalidationReason(),
02879                 invalidationMessage()
02880             ));
02881         }
02882 
02883 
02884         return asyncCall(QLatin1String("ClearStatus"));
02885     }
02886 
02905     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
02906     {
02907         if (!invalidationReason().isEmpty()) {
02908             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
02909                 invalidationReason(),
02910                 invalidationMessage()
02911             ));
02912         }
02913 
02914 
02915         QList<QVariant> argumentList;
02916         argumentList << QVariant::fromValue(contacts);
02917         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
02918     }
02919 
02936     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
02937     {
02938         if (!invalidationReason().isEmpty()) {
02939             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
02940                 invalidationReason(),
02941                 invalidationMessage()
02942             ));
02943         }
02944 
02945 
02946         return asyncCall(QLatin1String("GetStatuses"));
02947     }
02948 
02962     inline QDBusPendingReply<> RemoveStatus(const QString& status)
02963     {
02964         if (!invalidationReason().isEmpty()) {
02965             return QDBusPendingReply<>(QDBusMessage::createError(
02966                 invalidationReason(),
02967                 invalidationMessage()
02968             ));
02969         }
02970 
02971 
02972         QList<QVariant> argumentList;
02973         argumentList << QVariant::fromValue(status);
02974         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
02975     }
02976 
02990     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
02991     {
02992         if (!invalidationReason().isEmpty()) {
02993             return QDBusPendingReply<>(QDBusMessage::createError(
02994                 invalidationReason(),
02995                 invalidationMessage()
02996             ));
02997         }
02998 
02999 
03000         QList<QVariant> argumentList;
03001         argumentList << QVariant::fromValue(contacts);
03002         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
03003     }
03004 
03015     inline QDBusPendingReply<> SetLastActivityTime(uint time)
03016     {
03017         if (!invalidationReason().isEmpty()) {
03018             return QDBusPendingReply<>(QDBusMessage::createError(
03019                 invalidationReason(),
03020                 invalidationMessage()
03021             ));
03022         }
03023 
03024 
03025         QList<QVariant> argumentList;
03026         argumentList << QVariant::fromValue(time);
03027         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
03028     }
03029 
03060     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
03061     {
03062         if (!invalidationReason().isEmpty()) {
03063             return QDBusPendingReply<>(QDBusMessage::createError(
03064                 invalidationReason(),
03065                 invalidationMessage()
03066             ));
03067         }
03068 
03069 
03070         QList<QVariant> argumentList;
03071         argumentList << QVariant::fromValue(statuses);
03072         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
03073     }
03074 
03075 Q_SIGNALS:
03092     void PresenceUpdate(const Tp::ContactPresences& presence);
03093 
03094 protected:
03095     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03096 };
03097 
03105 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
03106 {
03107     Q_OBJECT
03108 
03109 public:
03116     static inline const char *staticInterfaceName()
03117     {
03118         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
03119     }
03120 
03128     ConnectionInterfaceRequestsInterface(
03129         const QString& busName,
03130         const QString& objectPath,
03131         QObject* parent = 0
03132     );
03133 
03142     ConnectionInterfaceRequestsInterface(
03143         const QDBusConnection& connection,
03144         const QString& busName,
03145         const QString& objectPath,
03146         QObject* parent = 0
03147     );
03148 
03155     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
03156 
03164     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03165 
03173     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03174 
03181     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
03182 
03183     
03191     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
03192     {
03193         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
03194     }
03195 
03219     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
03220 
03221     
03229     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
03230     {
03231         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
03232     }
03233 
03234 public Q_SLOTS:
03303     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
03304     {
03305         if (!invalidationReason().isEmpty()) {
03306             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03307                 invalidationReason(),
03308                 invalidationMessage()
03309             ));
03310         }
03311 
03312 
03313         QList<QVariant> argumentList;
03314         argumentList << QVariant::fromValue(request);
03315         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
03316     }
03317 
03369     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
03370     {
03371         if (!invalidationReason().isEmpty()) {
03372             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03373                 invalidationReason(),
03374                 invalidationMessage()
03375             ));
03376         }
03377 
03378 
03379         QList<QVariant> argumentList;
03380         argumentList << QVariant::fromValue(request);
03381         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
03382     }
03383 
03384 Q_SIGNALS:
03426     void NewChannels(const Tp::ChannelDetailsList& channels);
03427 
03440     void ChannelClosed(const QDBusObjectPath& removed);
03441 
03442 protected:
03443     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03444 };
03445 
03453 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
03454 {
03455     Q_OBJECT
03456 
03457 public:
03464     static inline const char *staticInterfaceName()
03465     {
03466         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
03467     }
03468 
03476     ConnectionInterfaceSimplePresenceInterface(
03477         const QString& busName,
03478         const QString& objectPath,
03479         QObject* parent = 0
03480     );
03481 
03490     ConnectionInterfaceSimplePresenceInterface(
03491         const QDBusConnection& connection,
03492         const QString& busName,
03493         const QString& objectPath,
03494         QObject* parent = 0
03495     );
03496 
03503     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
03504 
03512     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
03513 
03521     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03522 
03558     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
03559 
03560     
03568     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
03569     {
03570         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
03571     }
03572 
03573 public Q_SLOTS:
03628     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
03629     {
03630         if (!invalidationReason().isEmpty()) {
03631             return QDBusPendingReply<>(QDBusMessage::createError(
03632                 invalidationReason(),
03633                 invalidationMessage()
03634             ));
03635         }
03636 
03637 
03638         QList<QVariant> argumentList;
03639         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
03640         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
03641     }
03642 
03667     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
03668     {
03669         if (!invalidationReason().isEmpty()) {
03670             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
03671                 invalidationReason(),
03672                 invalidationMessage()
03673             ));
03674         }
03675 
03676 
03677         QList<QVariant> argumentList;
03678         argumentList << QVariant::fromValue(contacts);
03679         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
03680     }
03681 
03682 Q_SIGNALS:
03695     void PresencesChanged(const Tp::SimpleContactPresences& presence);
03696 
03697 protected:
03698     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03699 };
03700 }
03701 }
03702 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
03703 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
03704 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
03705 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceBalanceInterface*)
03706 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
03707 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
03708 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
03709 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
03710 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
03711 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
03712 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
03713 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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