TelepathyQt4: cli-connection.h Source File

| 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
    00107     Q_PROPERTY(uint SelfHandle READ SelfHandle)
    00108
    00109
    00117     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
    00118     {
    00119         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
    00120     }
    00121
    00122 public Q_SLOTS:
    00133     inline QDBusPendingReply<> Connect()
    00134     {
    00135         if (!invalidationReason().isEmpty()) {
    00136             return QDBusPendingReply<>(QDBusMessage::createError(
    00137                 invalidationReason(),
    00138                 invalidationMessage()
    00139             ));
    00140         }
    00141
    00142
    00143         return asyncCall(QLatin1String("Connect"));
    00144     }
    00145
    00153     inline QDBusPendingReply<> Disconnect()
    00154     {
    00155         if (!invalidationReason().isEmpty()) {
    00156             return QDBusPendingReply<>(QDBusMessage::createError(
    00157                 invalidationReason(),
    00158                 invalidationMessage()
    00159             ));
    00160         }
    00161
    00162
    00163         return asyncCall(QLatin1String("Disconnect"));
    00164     }
    00165
    00195     inline QDBusPendingReply<QStringList> GetInterfaces()
    00196     {
    00197         if (!invalidationReason().isEmpty()) {
    00198             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    00199                 invalidationReason(),
    00200                 invalidationMessage()
    00201             ));
    00202         }
    00203
    00204
    00205         return asyncCall(QLatin1String("GetInterfaces"));
    00206     }
    00207
    00217     inline QDBusPendingReply<QString> GetProtocol()
    00218     {
    00219         if (!invalidationReason().isEmpty()) {
    00220             return QDBusPendingReply<QString>(QDBusMessage::createError(
    00221                 invalidationReason(),
    00222                 invalidationMessage()
    00223             ));
    00224         }
    00225
    00226
    00227         return asyncCall(QLatin1String("GetProtocol"));
    00228     }
    00229
    00240     inline QDBusPendingReply<uint> GetSelfHandle()
    00241     {
    00242         if (!invalidationReason().isEmpty()) {
    00243             return QDBusPendingReply<uint>(QDBusMessage::createError(
    00244                 invalidationReason(),
    00245                 invalidationMessage()
    00246             ));
    00247         }
    00248
    00249
    00250         return asyncCall(QLatin1String("GetSelfHandle"));
    00251     }
    00252
    00262     inline QDBusPendingReply<uint> GetStatus()
    00263     {
    00264         if (!invalidationReason().isEmpty()) {
    00265             return QDBusPendingReply<uint>(QDBusMessage::createError(
    00266                 invalidationReason(),
    00267                 invalidationMessage()
    00268             ));
    00269         }
    00270
    00271
    00272         return asyncCall(QLatin1String("GetStatus"));
    00273     }
    00274
    00304     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles)
    00305     {
    00306         if (!invalidationReason().isEmpty()) {
    00307             return QDBusPendingReply<>(QDBusMessage::createError(
    00308                 invalidationReason(),
    00309                 invalidationMessage()
    00310             ));
    00311         }
    00312
    00313
    00314         QList<QVariant> argumentList;
    00315         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
    00316         return asyncCallWithArgumentList(QLatin1String("HoldHandles"), argumentList);
    00317     }
    00318
    00337     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles)
    00338     {
    00339         if (!invalidationReason().isEmpty()) {
    00340             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    00341                 invalidationReason(),
    00342                 invalidationMessage()
    00343             ));
    00344         }
    00345
    00346
    00347         QList<QVariant> argumentList;
    00348         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
    00349         return asyncCallWithArgumentList(QLatin1String("InspectHandles"), argumentList);
    00350     }
    00351
    00361     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels()
    00362     {
    00363         if (!invalidationReason().isEmpty()) {
    00364             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
    00365                 invalidationReason(),
    00366                 invalidationMessage()
    00367             ));
    00368         }
    00369
    00370
    00371         return asyncCall(QLatin1String("ListChannels"));
    00372     }
    00373
    00390     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles)
    00391     {
    00392         if (!invalidationReason().isEmpty()) {
    00393             return QDBusPendingReply<>(QDBusMessage::createError(
    00394                 invalidationReason(),
    00395                 invalidationMessage()
    00396             ));
    00397         }
    00398
    00399
    00400         QList<QVariant> argumentList;
    00401         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
    00402         return asyncCallWithArgumentList(QLatin1String("ReleaseHandles"), argumentList);
    00403     }
    00404
    00477     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler)
    00478     {
    00479         if (!invalidationReason().isEmpty()) {
    00480             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
    00481                 invalidationReason(),
    00482                 invalidationMessage()
    00483             ));
    00484         }
    00485
    00486
    00487         QList<QVariant> argumentList;
    00488         argumentList << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
    00489         return asyncCallWithArgumentList(QLatin1String("RequestChannel"), argumentList);
    00490     }
    00491
    00518     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& identifiers)
    00519     {
    00520         if (!invalidationReason().isEmpty()) {
    00521             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    00522                 invalidationReason(),
    00523                 invalidationMessage()
    00524             ));
    00525         }
    00526
    00527
    00528         QList<QVariant> argumentList;
    00529         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(identifiers);
    00530         return asyncCallWithArgumentList(QLatin1String("RequestHandles"), argumentList);
    00531     }
    00532
    00533 Q_SIGNALS:
    00545     void SelfHandleChanged(uint selfHandle);
    00546
    00588     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
    00589
    00653     void ConnectionError(const QString& error, const QVariantMap& details);
    00654
    00671     void StatusChanged(uint status, uint reason);
    00672
    00673 protected:
    00674     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    00675 };
    00676
    00684 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
    00685 {
    00686     Q_OBJECT
    00687
    00688 public:
    00695     static inline const char *staticInterfaceName()
    00696     {
    00697         return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
    00698     }
    00699
    00707     ConnectionInterfaceAliasingInterface(
    00708         const QString& busName,
    00709         const QString& objectPath,
    00710         QObject* parent = 0
    00711     );
    00712
    00721     ConnectionInterfaceAliasingInterface(
    00722         const QDBusConnection& connection,
    00723         const QString& busName,
    00724         const QString& objectPath,
    00725         QObject* parent = 0
    00726     );
    00727
    00734     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
    00735
    00743     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
    00744
    00752     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    00753
    00754 public Q_SLOTS:
    00765     inline QDBusPendingReply<uint> GetAliasFlags()
    00766     {
    00767         if (!invalidationReason().isEmpty()) {
    00768             return QDBusPendingReply<uint>(QDBusMessage::createError(
    00769                 invalidationReason(),
    00770                 invalidationMessage()
    00771             ));
    00772         }
    00773
    00774
    00775         return asyncCall(QLatin1String("GetAliasFlags"));
    00776     }
    00777
    00791     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
    00792     {
    00793         if (!invalidationReason().isEmpty()) {
    00794             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    00795                 invalidationReason(),
    00796                 invalidationMessage()
    00797             ));
    00798         }
    00799
    00800
    00801         QList<QVariant> argumentList;
    00802         argumentList << QVariant::fromValue(contacts);
    00803         return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
    00804     }
    00805
    00823     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
    00824     {
    00825         if (!invalidationReason().isEmpty()) {
    00826             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
    00827                 invalidationReason(),
    00828                 invalidationMessage()
    00829             ));
    00830         }
    00831
    00832
    00833         QList<QVariant> argumentList;
    00834         argumentList << QVariant::fromValue(contacts);
    00835         return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
    00836     }
    00837
    00852     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
    00853     {
    00854         if (!invalidationReason().isEmpty()) {
    00855             return QDBusPendingReply<>(QDBusMessage::createError(
    00856                 invalidationReason(),
    00857                 invalidationMessage()
    00858             ));
    00859         }
    00860
    00861
    00862         QList<QVariant> argumentList;
    00863         argumentList << QVariant::fromValue(aliases);
    00864         return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
    00865     }
    00866
    00867 Q_SIGNALS:
    00882     void AliasesChanged(const Tp::AliasPairList& aliases);
    00883
    00884 protected:
    00885     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    00886 };
    00887
    00895 class TELEPATHY_QT4_EXPORT ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
    00896 {
    00897     Q_OBJECT
    00898
    00899 public:
    00906     static inline const char *staticInterfaceName()
    00907     {
    00908         return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
    00909     }
    00910
    00918     ConnectionInterfaceAvatarsInterface(
    00919         const QString& busName,
    00920         const QString& objectPath,
    00921         QObject* parent = 0
    00922     );
    00923
    00932     ConnectionInterfaceAvatarsInterface(
    00933         const QDBusConnection& connection,
    00934         const QString& busName,
    00935         const QString& objectPath,
    00936         QObject* parent = 0
    00937     );
    00938
    00945     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
    00946
    00954     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    00955
    00963     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    00964
    00972     Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
    00973
    00974
    00982     inline QStringList SupportedAvatarMIMETypes() const TELEPATHY_GNUC_DEPRECATED
    00983     {
    00984         return qvariant_cast<QStringList>(internalPropGet("SupportedAvatarMIMETypes"));
    00985     }
    00986
    00994     Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
    00995
    00996
    01004     inline uint MinimumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
    01005     {
    01006         return qvariant_cast<uint>(internalPropGet("MinimumAvatarHeight"));
    01007     }
    01008
    01016     Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
    01017
    01018
    01026     inline uint MinimumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
    01027     {
    01028         return qvariant_cast<uint>(internalPropGet("MinimumAvatarWidth"));
    01029     }
    01030
    01041     Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
    01042
    01043
    01051     inline uint RecommendedAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
    01052     {
    01053         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarHeight"));
    01054     }
    01055
    01064     Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
    01065
    01066
    01074     inline uint RecommendedAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
    01075     {
    01076         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarWidth"));
    01077     }
    01078
    01086     Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
    01087
    01088
    01096     inline uint MaximumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
    01097     {
    01098         return qvariant_cast<uint>(internalPropGet("MaximumAvatarHeight"));
    01099     }
    01100
    01108     Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
    01109
    01110
    01118     inline uint MaximumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
    01119     {
    01120         return qvariant_cast<uint>(internalPropGet("MaximumAvatarWidth"));
    01121     }
    01122
    01130     Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
    01131
    01132
    01140     inline uint MaximumAvatarBytes() const TELEPATHY_GNUC_DEPRECATED
    01141     {
    01142         return qvariant_cast<uint>(internalPropGet("MaximumAvatarBytes"));
    01143     }
    01144
    01145 public Q_SLOTS:
    01175     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
    01176     {
    01177         if (!invalidationReason().isEmpty()) {
    01178             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
    01179                 invalidationReason(),
    01180                 invalidationMessage()
    01181             ));
    01182         }
    01183
    01184
    01185         return asyncCall(QLatin1String("GetAvatarRequirements"));
    01186     }
    01187
    01204     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
    01205     {
    01206         if (!invalidationReason().isEmpty()) {
    01207             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    01208                 invalidationReason(),
    01209                 invalidationMessage()
    01210             ));
    01211         }
    01212
    01213
    01214         QList<QVariant> argumentList;
    01215         argumentList << QVariant::fromValue(contacts);
    01216         return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
    01217     }
    01218
    01241     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
    01242     {
    01243         if (!invalidationReason().isEmpty()) {
    01244             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
    01245                 invalidationReason(),
    01246                 invalidationMessage()
    01247             ));
    01248         }
    01249
    01250
    01251         QList<QVariant> argumentList;
    01252         argumentList << QVariant::fromValue(contacts);
    01253         return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
    01254     }
    01255
    01275     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
    01276     {
    01277         if (!invalidationReason().isEmpty()) {
    01278             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
    01279                 invalidationReason(),
    01280                 invalidationMessage()
    01281             ));
    01282         }
    01283
    01284
    01285         QList<QVariant> argumentList;
    01286         argumentList << QVariant::fromValue(contact);
    01287         return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
    01288     }
    01289
    01303     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
    01304     {
    01305         if (!invalidationReason().isEmpty()) {
    01306             return QDBusPendingReply<>(QDBusMessage::createError(
    01307                 invalidationReason(),
    01308                 invalidationMessage()
    01309             ));
    01310         }
    01311
    01312
    01313         QList<QVariant> argumentList;
    01314         argumentList << QVariant::fromValue(contacts);
    01315         return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
    01316     }
    01317
    01336     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
    01337     {
    01338         if (!invalidationReason().isEmpty()) {
    01339             return QDBusPendingReply<QString>(QDBusMessage::createError(
    01340                 invalidationReason(),
    01341                 invalidationMessage()
    01342             ));
    01343         }
    01344
    01345
    01346         QList<QVariant> argumentList;
    01347         argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
    01348         return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
    01349     }
    01350
    01356     inline QDBusPendingReply<> ClearAvatar()
    01357     {
    01358         if (!invalidationReason().isEmpty()) {
    01359             return QDBusPendingReply<>(QDBusMessage::createError(
    01360                 invalidationReason(),
    01361                 invalidationMessage()
    01362             ));
    01363         }
    01364
    01365
    01366         return asyncCall(QLatin1String("ClearAvatar"));
    01367     }
    01368
    01369 Q_SIGNALS:
    01386     void AvatarUpdated(uint contact, const QString& newAvatarToken);
    01387
    01410     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
    01411
    01412 protected:
    01413     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01414 };
    01415
    01423 class TELEPATHY_QT4_EXPORT ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
    01424 {
    01425     Q_OBJECT
    01426
    01427 public:
    01434     static inline const char *staticInterfaceName()
    01435     {
    01436         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
    01437     }
    01438
    01446     ConnectionInterfaceCapabilitiesInterface(
    01447         const QString& busName,
    01448         const QString& objectPath,
    01449         QObject* parent = 0
    01450     );
    01451
    01460     ConnectionInterfaceCapabilitiesInterface(
    01461         const QDBusConnection& connection,
    01462         const QString& busName,
    01463         const QString& objectPath,
    01464         QObject* parent = 0
    01465     );
    01466
    01473     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
    01474
    01482     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01483
    01491     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01492
    01493 public Q_SLOTS:
    01538     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
    01539     {
    01540         if (!invalidationReason().isEmpty()) {
    01541             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
    01542                 invalidationReason(),
    01543                 invalidationMessage()
    01544             ));
    01545         }
    01546
    01547
    01548         QList<QVariant> argumentList;
    01549         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
    01550         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
    01551     }
    01552
    01578     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
    01579     {
    01580         if (!invalidationReason().isEmpty()) {
    01581             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
    01582                 invalidationReason(),
    01583                 invalidationMessage()
    01584             ));
    01585         }
    01586
    01587
    01588         QList<QVariant> argumentList;
    01589         argumentList << QVariant::fromValue(handles);
    01590         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
    01591     }
    01592
    01593 Q_SIGNALS:
    01616     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
    01617
    01618 protected:
    01619     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01620 };
    01621
    01629 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactCapabilitiesInterface : public Tp::AbstractInterface
    01630 {
    01631     Q_OBJECT
    01632
    01633 public:
    01640     static inline const char *staticInterfaceName()
    01641     {
    01642         return "org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities";
    01643     }
    01644
    01652     ConnectionInterfaceContactCapabilitiesInterface(
    01653         const QString& busName,
    01654         const QString& objectPath,
    01655         QObject* parent = 0
    01656     );
    01657
    01666     ConnectionInterfaceContactCapabilitiesInterface(
    01667         const QDBusConnection& connection,
    01668         const QString& busName,
    01669         const QString& objectPath,
    01670         QObject* parent = 0
    01671     );
    01672
    01679     ConnectionInterfaceContactCapabilitiesInterface(Tp::DBusProxy *proxy);
    01680
    01688     explicit ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01689
    01697     ConnectionInterfaceContactCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01698
    01699 public Q_SLOTS:
    01755     inline QDBusPendingReply<> UpdateCapabilities(const Tp::HandlerCapabilitiesList& handlerCapabilities)
    01756     {
    01757         if (!invalidationReason().isEmpty()) {
    01758             return QDBusPendingReply<>(QDBusMessage::createError(
    01759                 invalidationReason(),
    01760                 invalidationMessage()
    01761             ));
    01762         }
    01763
    01764
    01765         QList<QVariant> argumentList;
    01766         argumentList << QVariant::fromValue(handlerCapabilities);
    01767         return asyncCallWithArgumentList(QLatin1String("UpdateCapabilities"), argumentList);
    01768     }
    01769
    01789     inline QDBusPendingReply<Tp::ContactCapabilitiesMap> GetContactCapabilities(const Tp::UIntList& handles)
    01790     {
    01791         if (!invalidationReason().isEmpty()) {
    01792             return QDBusPendingReply<Tp::ContactCapabilitiesMap>(QDBusMessage::createError(
    01793                 invalidationReason(),
    01794                 invalidationMessage()
    01795             ));
    01796         }
    01797
    01798
    01799         QList<QVariant> argumentList;
    01800         argumentList << QVariant::fromValue(handles);
    01801         return asyncCallWithArgumentList(QLatin1String("GetContactCapabilities"), argumentList);
    01802     }
    01803
    01804 Q_SIGNALS:
    01821     void ContactCapabilitiesChanged(const Tp::ContactCapabilitiesMap& caps);
    01822
    01823 protected:
    01824     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01825 };
    01826
    01834 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
    01835 {
    01836     Q_OBJECT
    01837
    01838 public:
    01845     static inline const char *staticInterfaceName()
    01846     {
    01847         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
    01848     }
    01849
    01857     ConnectionInterfaceContactsInterface(
    01858         const QString& busName,
    01859         const QString& objectPath,
    01860         QObject* parent = 0
    01861     );
    01862
    01871     ConnectionInterfaceContactsInterface(
    01872         const QDBusConnection& connection,
    01873         const QString& busName,
    01874         const QString& objectPath,
    01875         QObject* parent = 0
    01876     );
    01877
    01884     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
    01885
    01893     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    01894
    01902     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    01903
    01910     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
    01911
    01912
    01920     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
    01921     {
    01922         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
    01923     }
    01924
    01925 public Q_SLOTS:
    01989     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
    01990     {
    01991         if (!invalidationReason().isEmpty()) {
    01992             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
    01993                 invalidationReason(),
    01994                 invalidationMessage()
    01995             ));
    01996         }
    01997
    01998
    01999         QList<QVariant> argumentList;
    02000         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
    02001         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
    02002     }
    02003
    02004 protected:
    02005     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02006 };
    02007
    02015 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
    02016 {
    02017     Q_OBJECT
    02018
    02019 public:
    02026     static inline const char *staticInterfaceName()
    02027     {
    02028         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
    02029     }
    02030
    02038     ConnectionInterfacePresenceInterface(
    02039         const QString& busName,
    02040         const QString& objectPath,
    02041         QObject* parent = 0
    02042     );
    02043
    02052     ConnectionInterfacePresenceInterface(
    02053         const QDBusConnection& connection,
    02054         const QString& busName,
    02055         const QString& objectPath,
    02056         QObject* parent = 0
    02057     );
    02058
    02065     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
    02066
    02074     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02075
    02083     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02084
    02085 public Q_SLOTS:
    02102     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
    02103     {
    02104         if (!invalidationReason().isEmpty()) {
    02105             return QDBusPendingReply<>(QDBusMessage::createError(
    02106                 invalidationReason(),
    02107                 invalidationMessage()
    02108             ));
    02109         }
    02110
    02111
    02112         QList<QVariant> argumentList;
    02113         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
    02114         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
    02115     }
    02116
    02125     inline QDBusPendingReply<> ClearStatus()
    02126     {
    02127         if (!invalidationReason().isEmpty()) {
    02128             return QDBusPendingReply<>(QDBusMessage::createError(
    02129                 invalidationReason(),
    02130                 invalidationMessage()
    02131             ));
    02132         }
    02133
    02134
    02135         return asyncCall(QLatin1String("ClearStatus"));
    02136     }
    02137
    02156     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
    02157     {
    02158         if (!invalidationReason().isEmpty()) {
    02159             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
    02160                 invalidationReason(),
    02161                 invalidationMessage()
    02162             ));
    02163         }
    02164
    02165
    02166         QList<QVariant> argumentList;
    02167         argumentList << QVariant::fromValue(contacts);
    02168         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
    02169     }
    02170
    02187     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
    02188     {
    02189         if (!invalidationReason().isEmpty()) {
    02190             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
    02191                 invalidationReason(),
    02192                 invalidationMessage()
    02193             ));
    02194         }
    02195
    02196
    02197         return asyncCall(QLatin1String("GetStatuses"));
    02198     }
    02199
    02213     inline QDBusPendingReply<> RemoveStatus(const QString& status)
    02214     {
    02215         if (!invalidationReason().isEmpty()) {
    02216             return QDBusPendingReply<>(QDBusMessage::createError(
    02217                 invalidationReason(),
    02218                 invalidationMessage()
    02219             ));
    02220         }
    02221
    02222
    02223         QList<QVariant> argumentList;
    02224         argumentList << QVariant::fromValue(status);
    02225         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
    02226     }
    02227
    02241     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
    02242     {
    02243         if (!invalidationReason().isEmpty()) {
    02244             return QDBusPendingReply<>(QDBusMessage::createError(
    02245                 invalidationReason(),
    02246                 invalidationMessage()
    02247             ));
    02248         }
    02249
    02250
    02251         QList<QVariant> argumentList;
    02252         argumentList << QVariant::fromValue(contacts);
    02253         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
    02254     }
    02255
    02266     inline QDBusPendingReply<> SetLastActivityTime(uint time)
    02267     {
    02268         if (!invalidationReason().isEmpty()) {
    02269             return QDBusPendingReply<>(QDBusMessage::createError(
    02270                 invalidationReason(),
    02271                 invalidationMessage()
    02272             ));
    02273         }
    02274
    02275
    02276         QList<QVariant> argumentList;
    02277         argumentList << QVariant::fromValue(time);
    02278         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
    02279     }
    02280
    02311     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
    02312     {
    02313         if (!invalidationReason().isEmpty()) {
    02314             return QDBusPendingReply<>(QDBusMessage::createError(
    02315                 invalidationReason(),
    02316                 invalidationMessage()
    02317             ));
    02318         }
    02319
    02320
    02321         QList<QVariant> argumentList;
    02322         argumentList << QVariant::fromValue(statuses);
    02323         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
    02324     }
    02325
    02326 Q_SIGNALS:
    02343     void PresenceUpdate(const Tp::ContactPresences& presence);
    02344
    02345 protected:
    02346     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02347 };
    02348
    02356 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
    02357 {
    02358     Q_OBJECT
    02359
    02360 public:
    02367     static inline const char *staticInterfaceName()
    02368     {
    02369         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
    02370     }
    02371
    02379     ConnectionInterfaceRequestsInterface(
    02380         const QString& busName,
    02381         const QString& objectPath,
    02382         QObject* parent = 0
    02383     );
    02384
    02393     ConnectionInterfaceRequestsInterface(
    02394         const QDBusConnection& connection,
    02395         const QString& busName,
    02396         const QString& objectPath,
    02397         QObject* parent = 0
    02398     );
    02399
    02406     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
    02407
    02415     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02416
    02424     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02425
    02432     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
    02433
    02434
    02442     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
    02443     {
    02444         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
    02445     }
    02446
    02470     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
    02471
    02472
    02480     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
    02481     {
    02482         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
    02483     }
    02484
    02485 public Q_SLOTS:
    02554     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
    02555     {
    02556         if (!invalidationReason().isEmpty()) {
    02557             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    02558                 invalidationReason(),
    02559                 invalidationMessage()
    02560             ));
    02561         }
    02562
    02563
    02564         QList<QVariant> argumentList;
    02565         argumentList << QVariant::fromValue(request);
    02566         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
    02567     }
    02568
    02620     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
    02621     {
    02622         if (!invalidationReason().isEmpty()) {
    02623             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
    02624                 invalidationReason(),
    02625                 invalidationMessage()
    02626             ));
    02627         }
    02628
    02629
    02630         QList<QVariant> argumentList;
    02631         argumentList << QVariant::fromValue(request);
    02632         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
    02633     }
    02634
    02635 Q_SIGNALS:
    02677     void NewChannels(const Tp::ChannelDetailsList& channels);
    02678
    02691     void ChannelClosed(const QDBusObjectPath& removed);
    02692
    02693 protected:
    02694     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02695 };
    02696
    02704 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
    02705 {
    02706     Q_OBJECT
    02707
    02708 public:
    02715     static inline const char *staticInterfaceName()
    02716     {
    02717         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
    02718     }
    02719
    02727     ConnectionInterfaceSimplePresenceInterface(
    02728         const QString& busName,
    02729         const QString& objectPath,
    02730         QObject* parent = 0
    02731     );
    02732
    02741     ConnectionInterfaceSimplePresenceInterface(
    02742         const QDBusConnection& connection,
    02743         const QString& busName,
    02744         const QString& objectPath,
    02745         QObject* parent = 0
    02746     );
    02747
    02754     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
    02755
    02763     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
    02764
    02772     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
    02773
    02809     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
    02810
    02811
    02819     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
    02820     {
    02821         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
    02822     }
    02823
    02824 public Q_SLOTS:
    02879     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
    02880     {
    02881         if (!invalidationReason().isEmpty()) {
    02882             return QDBusPendingReply<>(QDBusMessage::createError(
    02883                 invalidationReason(),
    02884                 invalidationMessage()
    02885             ));
    02886         }
    02887
    02888
    02889         QList<QVariant> argumentList;
    02890         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
    02891         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
    02892     }
    02893
    02918     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
    02919     {
    02920         if (!invalidationReason().isEmpty()) {
    02921             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
    02922                 invalidationReason(),
    02923                 invalidationMessage()
    02924             ));
    02925         }
    02926
    02927
    02928         QList<QVariant> argumentList;
    02929         argumentList << QVariant::fromValue(contacts);
    02930         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
    02931     }
    02932
    02933 Q_SIGNALS:
    02946     void PresencesChanged(const Tp::SimpleContactPresences& presence);
    02947
    02948 protected:
    02949     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02950 };
    02951 }
    02952 }