| 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 ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
    01473 {
    01474     Q_OBJECT
    01475
    01476 public:
    01483     static inline const char *staticInterfaceName()
    01484     {
    01485         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
    01486     }
    01487
    01495     ConnectionInterfaceCapabilitiesInterface(
    01496         const QString& busName,
    01497         const QString& objectPath,
    01498         QObject* parent = 0
    01499     );
    01500
    01509     ConnectionInterfaceCapabilitiesInterface(
    01510         const QDBusConnection& connection,
    01511         const QString& busName,
    01512         const QString& objectPath,
    01513         QObject* parent = 0
    01514     );
    01515
    01522     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
    01523
    01531     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01532
    01540     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01541
    01542 public Q_SLOTS:
    01587     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
    01588     {
    01589         if (!invalidationReason().isEmpty()) {
    01590             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
    01591                 invalidationReason(),
    01592                 invalidationMessage()
    01593             ));
    01594         }
    01595
    01596
    01597         QList<QVariant> argumentList;
    01598         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
    01599         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
    01600     }
    01601
    01627     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
    01628     {
    01629         if (!invalidationReason().isEmpty()) {
    01630             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
    01631                 invalidationReason(),
    01632                 invalidationMessage()
    01633             ));
    01634         }
    01635
    01636
    01637         QList<QVariant> argumentList;
    01638         argumentList << QVariant::fromValue(handles);
    01639         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
    01640     }
    01641
    01642 Q_SIGNALS:
    01665     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
    01666
    01667 protected:
    01668     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01669 };
    01670
    01678 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
    01679 {
    01680     Q_OBJECT
    01681
    01682 public:
    01689     static inline const char *staticInterfaceName()
    01690     {
    01691         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
    01692     }
    01693
    01701     ConnectionInterfaceContactCapabilitiesInterface(
    01702         const QString& busName,
    01703         const QString& objectPath,
    01704         QObject* parent = 0
    01705     );
    01706
    01715     ConnectionInterfaceContactCapabilitiesInterface(
    01716         const QDBusConnection& connection,
    01717         const QString& busName,
    01718         const QString& objectPath,
    01719         QObject* parent = 0
    01720     );
    01721
    01728     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
    01729
    01737     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01738
    01746     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01747
    01748 public Q_SLOTS:
    01804     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
    01805     {
    01806         if (!invalidationReason().isEmpty()) {
    01807             return QDBusPendingReply<>(QDBusMessage::createError(
    01808                 invalidationReason(),
    01809                 invalidationMessage()
    01810             ));
    01811         }
    01812
    01813
    01814         QList<QVariant> argumentList;
    01815         argumentList << QVariant::fromValue(handlerCapabilities);
    01816         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
    01817     }
    01818
    01843     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
    01844     {
    01845         if (!invalidationReason().isEmpty()) {
    01846             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
    01847                 invalidationReason(),
    01848                 invalidationMessage()
    01849             ));
    01850         }
    01851
    01852
    01853         QList<QVariant> argumentList;
    01854         argumentList << QVariant::fromValue(handles);
    01855         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
    01856     }
    01857
    01858 Q_SIGNALS:
    01875     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
    01876
    01877 protected:
    01878     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01879 };
    01880
    01888 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
    01889 {
    01890     Q_OBJECT
    01891
    01892 public:
    01899     static inline const char *staticInterfaceName()
    01900     {
    01901         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
    01902     }
    01903
    01911     ConnectionInterfaceContactsInterface(
    01912         const QString& busName,
    01913         const QString& objectPath,
    01914         QObject* parent = 0
    01915     );
    01916
    01925     ConnectionInterfaceContactsInterface(
    01926         const QDBusConnection& connection,
    01927         const QString& busName,
    01928         const QString& objectPath,
    01929         QObject* parent = 0
    01930     );
    01931
    01938     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
    01939
    01947     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01948
    01956     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01957
    01964     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
    01965
    01966
    01974     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
    01975     {
    01976         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
    01977     }
    01978
    01979 public Q_SLOTS:
    02045     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
    02046     {
    02047         if (!invalidationReason().isEmpty()) {
    02048             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    02049                 invalidationReason(),
    02050                 invalidationMessage()
    02051             ));
    02052         }
    02053
    02054
    02055         QList<QVariant> argumentList;
    02056         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    02057         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
    02058     }
    02059
    02060 protected:
    02061     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02062 };
    02063
    02071 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
    02072 {
    02073     Q_OBJECT
    02074
    02075 public:
    02082     static inline const char *staticInterfaceName()
    02083     {
    02084         return "org.freedesktop.Telepathy.Connection.Interface.Location";
    02085     }
    02086
    02094     ConnectionInterfaceLocationInterface(
    02095         const QString& busName,
    02096         const QString& objectPath,
    02097         QObject* parent = 0
    02098     );
    02099
    02108     ConnectionInterfaceLocationInterface(
    02109         const QDBusConnection& connection,
    02110         const QString& busName,
    02111         const QString& objectPath,
    02112         QObject* parent = 0
    02113     );
    02114
    02121     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
    02122
    02130     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02131
    02139     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02140
    02146     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
    02147
    02148
    02156     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
    02157     {
    02158         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
    02159     }
    02160
    02169     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
    02170
    02171
    02179     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
    02180     {
    02181         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
    02182     }
    02183
    02191     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
    02192     {
    02193         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
    02194     }
    02195
    02196 public Q_SLOTS:
    02220     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
    02221     {
    02222         if (!invalidationReason().isEmpty()) {
    02223             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
    02224                 invalidationReason(),
    02225                 invalidationMessage()
    02226             ));
    02227         }
    02228
    02229
    02230         QList<QVariant> argumentList;
    02231         argumentList << QVariant::fromValue(contacts);
    02232         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
    02233     }
    02234
    02254     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
    02255     {
    02256         if (!invalidationReason().isEmpty()) {
    02257             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
    02258                 invalidationReason(),
    02259                 invalidationMessage()
    02260             ));
    02261         }
    02262
    02263
    02264         QList<QVariant> argumentList;
    02265         argumentList << QVariant::fromValue(contact);
    02266         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
    02267     }
    02268
    02285     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
    02286     {
    02287         if (!invalidationReason().isEmpty()) {
    02288             return QDBusPendingReply<>(QDBusMessage::createError(
    02289                 invalidationReason(),
    02290                 invalidationMessage()
    02291             ));
    02292         }
    02293
    02294
    02295         QList<QVariant> argumentList;
    02296         argumentList << QVariant::fromValue(location);
    02297         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
    02298     }
    02299
    02300 Q_SIGNALS:
    02315     void LocationUpdated(uint contact, const QVariantMap& location);
    02316
    02317 protected:
    02318     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02319 };
    02320
    02328 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
    02329 {
    02330     Q_OBJECT
    02331
    02332 public:
    02339     static inline const char *staticInterfaceName()
    02340     {
    02341         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
    02342     }
    02343
    02351     ConnectionInterfacePresenceInterface(
    02352         const QString& busName,
    02353         const QString& objectPath,
    02354         QObject* parent = 0
    02355     );
    02356
    02365     ConnectionInterfacePresenceInterface(
    02366         const QDBusConnection& connection,
    02367         const QString& busName,
    02368         const QString& objectPath,
    02369         QObject* parent = 0
    02370     );
    02371
    02378     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
    02379
    02387     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02388
    02396     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02397
    02398 public Q_SLOTS:
    02415     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
    02416     {
    02417         if (!invalidationReason().isEmpty()) {
    02418             return QDBusPendingReply<>(QDBusMessage::createError(
    02419                 invalidationReason(),
    02420                 invalidationMessage()
    02421             ));
    02422         }
    02423
    02424
    02425         QList<QVariant> argumentList;
    02426         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
    02427         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
    02428     }
    02429
    02438     inline QDBusPendingReply<> ClearStatus()
    02439     {
    02440         if (!invalidationReason().isEmpty()) {
    02441             return QDBusPendingReply<>(QDBusMessage::createError(
    02442                 invalidationReason(),
    02443                 invalidationMessage()
    02444             ));
    02445         }
    02446
    02447
    02448         return asyncCall(QLatin1String("ClearStatus"));
    02449     }
    02450
    02469     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
    02470     {
    02471         if (!invalidationReason().isEmpty()) {
    02472             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
    02473                 invalidationReason(),
    02474                 invalidationMessage()
    02475             ));
    02476         }
    02477
    02478
    02479         QList<QVariant> argumentList;
    02480         argumentList << QVariant::fromValue(contacts);
    02481         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
    02482     }
    02483
    02500     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
    02501     {
    02502         if (!invalidationReason().isEmpty()) {
    02503             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
    02504                 invalidationReason(),
    02505                 invalidationMessage()
    02506             ));
    02507         }
    02508
    02509
    02510         return asyncCall(QLatin1String("GetStatuses"));
    02511     }
    02512
    02526     inline QDBusPendingReply<> RemoveStatus(const QString& status)
    02527     {
    02528         if (!invalidationReason().isEmpty()) {
    02529             return QDBusPendingReply<>(QDBusMessage::createError(
    02530                 invalidationReason(),
    02531                 invalidationMessage()
    02532             ));
    02533         }
    02534
    02535
    02536         QList<QVariant> argumentList;
    02537         argumentList << QVariant::fromValue(status);
    02538         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
    02539     }
    02540
    02554     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
    02555     {
    02556         if (!invalidationReason().isEmpty()) {
    02557             return QDBusPendingReply<>(QDBusMessage::createError(
    02558                 invalidationReason(),
    02559                 invalidationMessage()
    02560             ));
    02561         }
    02562
    02563
    02564         QList<QVariant> argumentList;
    02565         argumentList << QVariant::fromValue(contacts);
    02566         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
    02567     }
    02568
    02579     inline QDBusPendingReply<> SetLastActivityTime(uint time)
    02580     {
    02581         if (!invalidationReason().isEmpty()) {
    02582             return QDBusPendingReply<>(QDBusMessage::createError(
    02583                 invalidationReason(),
    02584                 invalidationMessage()
    02585             ));
    02586         }
    02587
    02588
    02589         QList<QVariant> argumentList;
    02590         argumentList << QVariant::fromValue(time);
    02591         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
    02592     }
    02593
    02624     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
    02625     {
    02626         if (!invalidationReason().isEmpty()) {
    02627             return QDBusPendingReply<>(QDBusMessage::createError(
    02628                 invalidationReason(),
    02629                 invalidationMessage()
    02630             ));
    02631         }
    02632
    02633
    02634         QList<QVariant> argumentList;
    02635         argumentList << QVariant::fromValue(statuses);
    02636         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
    02637     }
    02638
    02639 Q_SIGNALS:
    02656     void PresenceUpdate(const Tp::ContactPresences& presence);
    02657
    02658 protected:
    02659     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02660 };
    02661
    02669 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
    02670 {
    02671     Q_OBJECT
    02672
    02673 public:
    02680     static inline const char *staticInterfaceName()
    02681     {
    02682         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
    02683     }
    02684
    02692     ConnectionInterfaceRequestsInterface(
    02693         const QString& busName,
    02694         const QString& objectPath,
    02695         QObject* parent = 0
    02696     );
    02697
    02706     ConnectionInterfaceRequestsInterface(
    02707         const QDBusConnection& connection,
    02708         const QString& busName,
    02709         const QString& objectPath,
    02710         QObject* parent = 0
    02711     );
    02712
    02719     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
    02720
    02728     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02729
    02737     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02738
    02745     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
    02746
    02747
    02755     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
    02756     {
    02757         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
    02758     }
    02759
    02783     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
    02784
    02785
    02793     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
    02794     {
    02795         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
    02796     }
    02797
    02798 public Q_SLOTS:
    02867     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
    02868     {
    02869         if (!invalidationReason().isEmpty()) {
    02870             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    02871                 invalidationReason(),
    02872                 invalidationMessage()
    02873             ));
    02874         }
    02875
    02876
    02877         QList<QVariant> argumentList;
    02878         argumentList << QVariant::fromValue(request);
    02879         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
    02880     }
    02881
    02933     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
    02934     {
    02935         if (!invalidationReason().isEmpty()) {
    02936             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    02937                 invalidationReason(),
    02938                 invalidationMessage()
    02939             ));
    02940         }
    02941
    02942
    02943         QList<QVariant> argumentList;
    02944         argumentList << QVariant::fromValue(request);
    02945         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
    02946     }
    02947
    02948 Q_SIGNALS:
    02990     void NewChannels(const Tp::ChannelDetailsList& channels);
    02991
    03004     void ChannelClosed(const QDBusObjectPath& removed);
    03005
    03006 protected:
    03007     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03008 };
    03009
    03017 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
    03018 {
    03019     Q_OBJECT
    03020
    03021 public:
    03028     static inline const char *staticInterfaceName()
    03029     {
    03030         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
    03031     }
    03032
    03040     ConnectionInterfaceSimplePresenceInterface(
    03041         const QString& busName,
    03042         const QString& objectPath,
    03043         QObject* parent = 0
    03044     );
    03045
    03054     ConnectionInterfaceSimplePresenceInterface(
    03055         const QDBusConnection& connection,
    03056         const QString& busName,
    03057         const QString& objectPath,
    03058         QObject* parent = 0
    03059     );
    03060
    03067     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
    03068
    03076     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    03077
    03085     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    03086
    03122     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
    03123
    03124
    03132     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
    03133     {
    03134         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
    03135     }
    03136
    03137 public Q_SLOTS:
    03192     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
    03193     {
    03194         if (!invalidationReason().isEmpty()) {
    03195             return QDBusPendingReply<>(QDBusMessage::createError(
    03196                 invalidationReason(),
    03197                 invalidationMessage()
    03198             ));
    03199         }
    03200
    03201
    03202         QList<QVariant> argumentList;
    03203         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
    03204         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
    03205     }
    03206
    03231     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
    03232     {
    03233         if (!invalidationReason().isEmpty()) {
    03234             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
    03235                 invalidationReason(),
    03236                 invalidationMessage()
    03237             ));
    03238         }
    03239
    03240
    03241         QList<QVariant> argumentList;
    03242         argumentList << QVariant::fromValue(contacts);
    03243         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
    03244     }
    03245
    03246 Q_SIGNALS:
    03259     void PresencesChanged(const Tp::SimpleContactPresences& presence);
    03260
    03261 protected:
    03262     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03263 };
    03264 }
    03265 }
    03266 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
    03267 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
    03268 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
    03269 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
    03270 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
    03271 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
    03272 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
    03273 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
    03274 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
    03275 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)