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 
00025 // basically the same as GLib's G_GNUC_DEPRECATED
00026 #ifndef TELEPATHY_GNUC_DEPRECATED
00027 #   if defined(Q_CC_GNUC) && __GNUC__ >= 4
00028 #       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
00029 #   else
00030 #       define TELEPATHY_GNUC_DEPRECATED
00031 #   endif
00032 #endif
00033 namespace Tp
00034 {
00035 namespace Client
00036 {
00037 
00045 class ConnectionInterface : public Tp::AbstractInterface
00046 {
00047     Q_OBJECT
00048 
00049 public:
00056     static inline const char *staticInterfaceName()
00057     {
00058         return "org.freedesktop.Telepathy.Connection";
00059     }
00060 
00068     ConnectionInterface(
00069         const QString& busName,
00070         const QString& objectPath,
00071         QObject* parent = 0
00072     );
00073 
00082     ConnectionInterface(
00083         const QDBusConnection& connection,
00084         const QString& busName,
00085         const QString& objectPath,
00086         QObject* parent = 0
00087     );
00088 
00095     ConnectionInterface(Tp::DBusProxy *proxy);
00096 
00106     Q_PROPERTY(uint SelfHandle READ SelfHandle)
00107 
00108     
00116     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
00117     {
00118         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
00119     }
00120 
00121 public Q_SLOTS:
00132     inline QDBusPendingReply<> Connect()
00133     {
00134         if (!invalidationReason().isEmpty()) {
00135             return QDBusPendingReply<>(QDBusMessage::createError(
00136                 invalidationReason(),
00137                 invalidationMessage()
00138             ));
00139         }
00140 
00141 
00142         return asyncCall(QLatin1String("Connect"));
00143     }
00144 
00152     inline QDBusPendingReply<> Disconnect()
00153     {
00154         if (!invalidationReason().isEmpty()) {
00155             return QDBusPendingReply<>(QDBusMessage::createError(
00156                 invalidationReason(),
00157                 invalidationMessage()
00158             ));
00159         }
00160 
00161 
00162         return asyncCall(QLatin1String("Disconnect"));
00163     }
00164 
00194     inline QDBusPendingReply<QStringList> GetInterfaces()
00195     {
00196         if (!invalidationReason().isEmpty()) {
00197             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00198                 invalidationReason(),
00199                 invalidationMessage()
00200             ));
00201         }
00202 
00203 
00204         return asyncCall(QLatin1String("GetInterfaces"));
00205     }
00206 
00216     inline QDBusPendingReply<QString> GetProtocol()
00217     {
00218         if (!invalidationReason().isEmpty()) {
00219             return QDBusPendingReply<QString>(QDBusMessage::createError(
00220                 invalidationReason(),
00221                 invalidationMessage()
00222             ));
00223         }
00224 
00225 
00226         return asyncCall(QLatin1String("GetProtocol"));
00227     }
00228 
00239     inline QDBusPendingReply<uint> GetSelfHandle()
00240     {
00241         if (!invalidationReason().isEmpty()) {
00242             return QDBusPendingReply<uint>(QDBusMessage::createError(
00243                 invalidationReason(),
00244                 invalidationMessage()
00245             ));
00246         }
00247 
00248 
00249         return asyncCall(QLatin1String("GetSelfHandle"));
00250     }
00251 
00261     inline QDBusPendingReply<uint> GetStatus()
00262     {
00263         if (!invalidationReason().isEmpty()) {
00264             return QDBusPendingReply<uint>(QDBusMessage::createError(
00265                 invalidationReason(),
00266                 invalidationMessage()
00267             ));
00268         }
00269 
00270 
00271         return asyncCall(QLatin1String("GetStatus"));
00272     }
00273 
00303     inline QDBusPendingReply<> HoldHandles(uint handleType, const Tp::UIntList& handles)
00304     {
00305         if (!invalidationReason().isEmpty()) {
00306             return QDBusPendingReply<>(QDBusMessage::createError(
00307                 invalidationReason(),
00308                 invalidationMessage()
00309             ));
00310         }
00311 
00312 
00313         QList<QVariant> argumentList;
00314         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00315         return asyncCallWithArgumentList(QLatin1String("HoldHandles"), argumentList);
00316     }
00317 
00335     inline QDBusPendingReply<QStringList> InspectHandles(uint handleType, const Tp::UIntList& handles)
00336     {
00337         if (!invalidationReason().isEmpty()) {
00338             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00339                 invalidationReason(),
00340                 invalidationMessage()
00341             ));
00342         }
00343 
00344 
00345         QList<QVariant> argumentList;
00346         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00347         return asyncCallWithArgumentList(QLatin1String("InspectHandles"), argumentList);
00348     }
00349 
00359     inline QDBusPendingReply<Tp::ChannelInfoList> ListChannels()
00360     {
00361         if (!invalidationReason().isEmpty()) {
00362             return QDBusPendingReply<Tp::ChannelInfoList>(QDBusMessage::createError(
00363                 invalidationReason(),
00364                 invalidationMessage()
00365             ));
00366         }
00367 
00368 
00369         return asyncCall(QLatin1String("ListChannels"));
00370     }
00371 
00388     inline QDBusPendingReply<> ReleaseHandles(uint handleType, const Tp::UIntList& handles)
00389     {
00390         if (!invalidationReason().isEmpty()) {
00391             return QDBusPendingReply<>(QDBusMessage::createError(
00392                 invalidationReason(),
00393                 invalidationMessage()
00394             ));
00395         }
00396 
00397 
00398         QList<QVariant> argumentList;
00399         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(handles);
00400         return asyncCallWithArgumentList(QLatin1String("ReleaseHandles"), argumentList);
00401     }
00402 
00475     inline QDBusPendingReply<QDBusObjectPath> RequestChannel(const QString& type, uint handleType, uint handle, bool suppressHandler)
00476     {
00477         if (!invalidationReason().isEmpty()) {
00478             return QDBusPendingReply<QDBusObjectPath>(QDBusMessage::createError(
00479                 invalidationReason(),
00480                 invalidationMessage()
00481             ));
00482         }
00483 
00484 
00485         QList<QVariant> argumentList;
00486         argumentList << QVariant::fromValue(type) << QVariant::fromValue(handleType) << QVariant::fromValue(handle) << QVariant::fromValue(suppressHandler);
00487         return asyncCallWithArgumentList(QLatin1String("RequestChannel"), argumentList);
00488     }
00489 
00515     inline QDBusPendingReply<Tp::UIntList> RequestHandles(uint handleType, const QStringList& names)
00516     {
00517         if (!invalidationReason().isEmpty()) {
00518             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
00519                 invalidationReason(),
00520                 invalidationMessage()
00521             ));
00522         }
00523 
00524 
00525         QList<QVariant> argumentList;
00526         argumentList << QVariant::fromValue(handleType) << QVariant::fromValue(names);
00527         return asyncCallWithArgumentList(QLatin1String("RequestHandles"), argumentList);
00528     }
00529 
00530 Q_SIGNALS:
00542     void SelfHandleChanged(uint selfHandle);
00543 
00585     void NewChannel(const QDBusObjectPath& objectPath, const QString& channelType, uint handleType, uint handle, bool suppressHandler);
00586 
00648     void ConnectionError(const QString& error, const QVariantMap& details);
00649 
00666     void StatusChanged(uint status, uint reason);
00667 
00668 protected:
00669     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00670 };
00671 
00679 class ConnectionInterfaceAliasingInterface : public Tp::AbstractInterface
00680 {
00681     Q_OBJECT
00682 
00683 public:
00690     static inline const char *staticInterfaceName()
00691     {
00692         return "org.freedesktop.Telepathy.Connection.Interface.Aliasing";
00693     }
00694 
00702     ConnectionInterfaceAliasingInterface(
00703         const QString& busName,
00704         const QString& objectPath,
00705         QObject* parent = 0
00706     );
00707 
00716     ConnectionInterfaceAliasingInterface(
00717         const QDBusConnection& connection,
00718         const QString& busName,
00719         const QString& objectPath,
00720         QObject* parent = 0
00721     );
00722 
00729     ConnectionInterfaceAliasingInterface(Tp::DBusProxy *proxy);
00730 
00738     explicit ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface);
00739 
00747     ConnectionInterfaceAliasingInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00748 
00749 public Q_SLOTS:
00760     inline QDBusPendingReply<uint> GetAliasFlags()
00761     {
00762         if (!invalidationReason().isEmpty()) {
00763             return QDBusPendingReply<uint>(QDBusMessage::createError(
00764                 invalidationReason(),
00765                 invalidationMessage()
00766             ));
00767         }
00768 
00769 
00770         return asyncCall(QLatin1String("GetAliasFlags"));
00771     }
00772 
00786     inline QDBusPendingReply<QStringList> RequestAliases(const Tp::UIntList& contacts)
00787     {
00788         if (!invalidationReason().isEmpty()) {
00789             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00790                 invalidationReason(),
00791                 invalidationMessage()
00792             ));
00793         }
00794 
00795 
00796         QList<QVariant> argumentList;
00797         argumentList << QVariant::fromValue(contacts);
00798         return asyncCallWithArgumentList(QLatin1String("RequestAliases"), argumentList);
00799     }
00800 
00817     inline QDBusPendingReply<Tp::AliasMap> GetAliases(const Tp::UIntList& contacts)
00818     {
00819         if (!invalidationReason().isEmpty()) {
00820             return QDBusPendingReply<Tp::AliasMap>(QDBusMessage::createError(
00821                 invalidationReason(),
00822                 invalidationMessage()
00823             ));
00824         }
00825 
00826 
00827         QList<QVariant> argumentList;
00828         argumentList << QVariant::fromValue(contacts);
00829         return asyncCallWithArgumentList(QLatin1String("GetAliases"), argumentList);
00830     }
00831 
00846     inline QDBusPendingReply<> SetAliases(const Tp::AliasMap& aliases)
00847     {
00848         if (!invalidationReason().isEmpty()) {
00849             return QDBusPendingReply<>(QDBusMessage::createError(
00850                 invalidationReason(),
00851                 invalidationMessage()
00852             ));
00853         }
00854 
00855 
00856         QList<QVariant> argumentList;
00857         argumentList << QVariant::fromValue(aliases);
00858         return asyncCallWithArgumentList(QLatin1String("SetAliases"), argumentList);
00859     }
00860 
00861 Q_SIGNALS:
00876     void AliasesChanged(const Tp::AliasPairList& aliases);
00877 
00878 protected:
00879     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00880 };
00881 
00889 class ConnectionInterfaceAvatarsInterface : public Tp::AbstractInterface
00890 {
00891     Q_OBJECT
00892 
00893 public:
00900     static inline const char *staticInterfaceName()
00901     {
00902         return "org.freedesktop.Telepathy.Connection.Interface.Avatars";
00903     }
00904 
00912     ConnectionInterfaceAvatarsInterface(
00913         const QString& busName,
00914         const QString& objectPath,
00915         QObject* parent = 0
00916     );
00917 
00926     ConnectionInterfaceAvatarsInterface(
00927         const QDBusConnection& connection,
00928         const QString& busName,
00929         const QString& objectPath,
00930         QObject* parent = 0
00931     );
00932 
00939     ConnectionInterfaceAvatarsInterface(Tp::DBusProxy *proxy);
00940 
00948     explicit ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface);
00949 
00957     ConnectionInterfaceAvatarsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
00958 
00966     Q_PROPERTY(QStringList SupportedAvatarMIMETypes READ SupportedAvatarMIMETypes)
00967 
00968     
00976     inline QStringList SupportedAvatarMIMETypes() const TELEPATHY_GNUC_DEPRECATED
00977     {
00978         return qvariant_cast<QStringList>(internalPropGet("SupportedAvatarMIMETypes"));
00979     }
00980 
00988     Q_PROPERTY(uint MinimumAvatarHeight READ MinimumAvatarHeight)
00989 
00990     
00998     inline uint MinimumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
00999     {
01000         return qvariant_cast<uint>(internalPropGet("MinimumAvatarHeight"));
01001     }
01002 
01010     Q_PROPERTY(uint MinimumAvatarWidth READ MinimumAvatarWidth)
01011 
01012     
01020     inline uint MinimumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01021     {
01022         return qvariant_cast<uint>(internalPropGet("MinimumAvatarWidth"));
01023     }
01024 
01035     Q_PROPERTY(uint RecommendedAvatarHeight READ RecommendedAvatarHeight)
01036 
01037     
01045     inline uint RecommendedAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01046     {
01047         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarHeight"));
01048     }
01049 
01058     Q_PROPERTY(uint RecommendedAvatarWidth READ RecommendedAvatarWidth)
01059 
01060     
01068     inline uint RecommendedAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01069     {
01070         return qvariant_cast<uint>(internalPropGet("RecommendedAvatarWidth"));
01071     }
01072 
01080     Q_PROPERTY(uint MaximumAvatarHeight READ MaximumAvatarHeight)
01081 
01082     
01090     inline uint MaximumAvatarHeight() const TELEPATHY_GNUC_DEPRECATED
01091     {
01092         return qvariant_cast<uint>(internalPropGet("MaximumAvatarHeight"));
01093     }
01094 
01102     Q_PROPERTY(uint MaximumAvatarWidth READ MaximumAvatarWidth)
01103 
01104     
01112     inline uint MaximumAvatarWidth() const TELEPATHY_GNUC_DEPRECATED
01113     {
01114         return qvariant_cast<uint>(internalPropGet("MaximumAvatarWidth"));
01115     }
01116 
01124     Q_PROPERTY(uint MaximumAvatarBytes READ MaximumAvatarBytes)
01125 
01126     
01134     inline uint MaximumAvatarBytes() const TELEPATHY_GNUC_DEPRECATED
01135     {
01136         return qvariant_cast<uint>(internalPropGet("MaximumAvatarBytes"));
01137     }
01138 
01139 public Q_SLOTS:
01169     inline QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint> GetAvatarRequirements()
01170     {
01171         if (!invalidationReason().isEmpty()) {
01172             return QDBusPendingReply<QStringList, ushort, ushort, ushort, ushort, uint>(QDBusMessage::createError(
01173                 invalidationReason(),
01174                 invalidationMessage()
01175             ));
01176         }
01177 
01178 
01179         return asyncCall(QLatin1String("GetAvatarRequirements"));
01180     }
01181 
01198     inline QDBusPendingReply<QStringList> GetAvatarTokens(const Tp::UIntList& contacts)
01199     {
01200         if (!invalidationReason().isEmpty()) {
01201             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
01202                 invalidationReason(),
01203                 invalidationMessage()
01204             ));
01205         }
01206 
01207 
01208         QList<QVariant> argumentList;
01209         argumentList << QVariant::fromValue(contacts);
01210         return asyncCallWithArgumentList(QLatin1String("GetAvatarTokens"), argumentList);
01211     }
01212 
01235     inline QDBusPendingReply<Tp::AvatarTokenMap> GetKnownAvatarTokens(const Tp::UIntList& contacts)
01236     {
01237         if (!invalidationReason().isEmpty()) {
01238             return QDBusPendingReply<Tp::AvatarTokenMap>(QDBusMessage::createError(
01239                 invalidationReason(),
01240                 invalidationMessage()
01241             ));
01242         }
01243 
01244 
01245         QList<QVariant> argumentList;
01246         argumentList << QVariant::fromValue(contacts);
01247         return asyncCallWithArgumentList(QLatin1String("GetKnownAvatarTokens"), argumentList);
01248     }
01249 
01269     inline QDBusPendingReply<QByteArray, QString> RequestAvatar(uint contact)
01270     {
01271         if (!invalidationReason().isEmpty()) {
01272             return QDBusPendingReply<QByteArray, QString>(QDBusMessage::createError(
01273                 invalidationReason(),
01274                 invalidationMessage()
01275             ));
01276         }
01277 
01278 
01279         QList<QVariant> argumentList;
01280         argumentList << QVariant::fromValue(contact);
01281         return asyncCallWithArgumentList(QLatin1String("RequestAvatar"), argumentList);
01282     }
01283 
01297     inline QDBusPendingReply<> RequestAvatars(const Tp::UIntList& contacts)
01298     {
01299         if (!invalidationReason().isEmpty()) {
01300             return QDBusPendingReply<>(QDBusMessage::createError(
01301                 invalidationReason(),
01302                 invalidationMessage()
01303             ));
01304         }
01305 
01306 
01307         QList<QVariant> argumentList;
01308         argumentList << QVariant::fromValue(contacts);
01309         return asyncCallWithArgumentList(QLatin1String("RequestAvatars"), argumentList);
01310     }
01311 
01330     inline QDBusPendingReply<QString> SetAvatar(const QByteArray& avatar, const QString& MIMEType)
01331     {
01332         if (!invalidationReason().isEmpty()) {
01333             return QDBusPendingReply<QString>(QDBusMessage::createError(
01334                 invalidationReason(),
01335                 invalidationMessage()
01336             ));
01337         }
01338 
01339 
01340         QList<QVariant> argumentList;
01341         argumentList << QVariant::fromValue(avatar) << QVariant::fromValue(MIMEType);
01342         return asyncCallWithArgumentList(QLatin1String("SetAvatar"), argumentList);
01343     }
01344 
01350     inline QDBusPendingReply<> ClearAvatar()
01351     {
01352         if (!invalidationReason().isEmpty()) {
01353             return QDBusPendingReply<>(QDBusMessage::createError(
01354                 invalidationReason(),
01355                 invalidationMessage()
01356             ));
01357         }
01358 
01359 
01360         return asyncCall(QLatin1String("ClearAvatar"));
01361     }
01362 
01363 Q_SIGNALS:
01380     void AvatarUpdated(uint contact, const QString& newAvatarToken);
01381 
01404     void AvatarRetrieved(uint contact, const QString& token, const QByteArray& avatar, const QString& type);
01405 
01406 protected:
01407     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01408 };
01409 
01417 class ConnectionInterfaceCapabilitiesInterface : public Tp::AbstractInterface
01418 {
01419     Q_OBJECT
01420 
01421 public:
01428     static inline const char *staticInterfaceName()
01429     {
01430         return "org.freedesktop.Telepathy.Connection.Interface.Capabilities";
01431     }
01432 
01440     ConnectionInterfaceCapabilitiesInterface(
01441         const QString& busName,
01442         const QString& objectPath,
01443         QObject* parent = 0
01444     );
01445 
01454     ConnectionInterfaceCapabilitiesInterface(
01455         const QDBusConnection& connection,
01456         const QString& busName,
01457         const QString& objectPath,
01458         QObject* parent = 0
01459     );
01460 
01467     ConnectionInterfaceCapabilitiesInterface(Tp::DBusProxy *proxy);
01468 
01476     explicit ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface);
01477 
01485     ConnectionInterfaceCapabilitiesInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01486 
01487 public Q_SLOTS:
01528     inline QDBusPendingReply<Tp::CapabilityPairList> AdvertiseCapabilities(const Tp::CapabilityPairList& add, const QStringList& remove)
01529     {
01530         if (!invalidationReason().isEmpty()) {
01531             return QDBusPendingReply<Tp::CapabilityPairList>(QDBusMessage::createError(
01532                 invalidationReason(),
01533                 invalidationMessage()
01534             ));
01535         }
01536 
01537 
01538         QList<QVariant> argumentList;
01539         argumentList << QVariant::fromValue(add) << QVariant::fromValue(remove);
01540         return asyncCallWithArgumentList(QLatin1String("AdvertiseCapabilities"), argumentList);
01541     }
01542 
01568     inline QDBusPendingReply<Tp::ContactCapabilityList> GetCapabilities(const Tp::UIntList& handles)
01569     {
01570         if (!invalidationReason().isEmpty()) {
01571             return QDBusPendingReply<Tp::ContactCapabilityList>(QDBusMessage::createError(
01572                 invalidationReason(),
01573                 invalidationMessage()
01574             ));
01575         }
01576 
01577 
01578         QList<QVariant> argumentList;
01579         argumentList << QVariant::fromValue(handles);
01580         return asyncCallWithArgumentList(QLatin1String("GetCapabilities"), argumentList);
01581     }
01582 
01583 Q_SIGNALS:
01606     void CapabilitiesChanged(const Tp::CapabilityChangeList& caps);
01607 
01608 protected:
01609     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01610 };
01611 
01619 class ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
01620 {
01621     Q_OBJECT
01622 
01623 public:
01630     static inline const char *staticInterfaceName()
01631     {
01632         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
01633     }
01634 
01642     ConnectionInterfaceContactsInterface(
01643         const QString& busName,
01644         const QString& objectPath,
01645         QObject* parent = 0
01646     );
01647 
01656     ConnectionInterfaceContactsInterface(
01657         const QDBusConnection& connection,
01658         const QString& busName,
01659         const QString& objectPath,
01660         QObject* parent = 0
01661     );
01662 
01669     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
01670 
01678     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
01679 
01687     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01688 
01695     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
01696 
01697     
01705     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
01706     {
01707         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
01708     }
01709 
01710 public Q_SLOTS:
01774     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
01775     {
01776         if (!invalidationReason().isEmpty()) {
01777             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
01778                 invalidationReason(),
01779                 invalidationMessage()
01780             ));
01781         }
01782 
01783 
01784         QList<QVariant> argumentList;
01785         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
01786         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
01787     }
01788 
01789 protected:
01790     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01791 };
01792 
01800 class ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
01801 {
01802     Q_OBJECT
01803 
01804 public:
01811     static inline const char *staticInterfaceName()
01812     {
01813         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
01814     }
01815 
01823     ConnectionInterfacePresenceInterface(
01824         const QString& busName,
01825         const QString& objectPath,
01826         QObject* parent = 0
01827     );
01828 
01837     ConnectionInterfacePresenceInterface(
01838         const QDBusConnection& connection,
01839         const QString& busName,
01840         const QString& objectPath,
01841         QObject* parent = 0
01842     );
01843 
01850     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
01851 
01859     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
01860 
01868     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01869 
01870 public Q_SLOTS:
01887     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
01888     {
01889         if (!invalidationReason().isEmpty()) {
01890             return QDBusPendingReply<>(QDBusMessage::createError(
01891                 invalidationReason(),
01892                 invalidationMessage()
01893             ));
01894         }
01895 
01896 
01897         QList<QVariant> argumentList;
01898         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
01899         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
01900     }
01901 
01910     inline QDBusPendingReply<> ClearStatus()
01911     {
01912         if (!invalidationReason().isEmpty()) {
01913             return QDBusPendingReply<>(QDBusMessage::createError(
01914                 invalidationReason(),
01915                 invalidationMessage()
01916             ));
01917         }
01918 
01919 
01920         return asyncCall(QLatin1String("ClearStatus"));
01921     }
01922 
01941     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
01942     {
01943         if (!invalidationReason().isEmpty()) {
01944             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
01945                 invalidationReason(),
01946                 invalidationMessage()
01947             ));
01948         }
01949 
01950 
01951         QList<QVariant> argumentList;
01952         argumentList << QVariant::fromValue(contacts);
01953         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
01954     }
01955 
01972     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
01973     {
01974         if (!invalidationReason().isEmpty()) {
01975             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
01976                 invalidationReason(),
01977                 invalidationMessage()
01978             ));
01979         }
01980 
01981 
01982         return asyncCall(QLatin1String("GetStatuses"));
01983     }
01984 
01998     inline QDBusPendingReply<> RemoveStatus(const QString& status)
01999     {
02000         if (!invalidationReason().isEmpty()) {
02001             return QDBusPendingReply<>(QDBusMessage::createError(
02002                 invalidationReason(),
02003                 invalidationMessage()
02004             ));
02005         }
02006 
02007 
02008         QList<QVariant> argumentList;
02009         argumentList << QVariant::fromValue(status);
02010         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
02011     }
02012 
02026     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
02027     {
02028         if (!invalidationReason().isEmpty()) {
02029             return QDBusPendingReply<>(QDBusMessage::createError(
02030                 invalidationReason(),
02031                 invalidationMessage()
02032             ));
02033         }
02034 
02035 
02036         QList<QVariant> argumentList;
02037         argumentList << QVariant::fromValue(contacts);
02038         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
02039     }
02040 
02051     inline QDBusPendingReply<> SetLastActivityTime(uint time)
02052     {
02053         if (!invalidationReason().isEmpty()) {
02054             return QDBusPendingReply<>(QDBusMessage::createError(
02055                 invalidationReason(),
02056                 invalidationMessage()
02057             ));
02058         }
02059 
02060 
02061         QList<QVariant> argumentList;
02062         argumentList << QVariant::fromValue(time);
02063         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
02064     }
02065 
02096     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
02097     {
02098         if (!invalidationReason().isEmpty()) {
02099             return QDBusPendingReply<>(QDBusMessage::createError(
02100                 invalidationReason(),
02101                 invalidationMessage()
02102             ));
02103         }
02104 
02105 
02106         QList<QVariant> argumentList;
02107         argumentList << QVariant::fromValue(statuses);
02108         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
02109     }
02110 
02111 Q_SIGNALS:
02128     void PresenceUpdate(const Tp::ContactPresences& presence);
02129 
02130 protected:
02131     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02132 };
02133 
02141 class ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
02142 {
02143     Q_OBJECT
02144 
02145 public:
02152     static inline const char *staticInterfaceName()
02153     {
02154         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
02155     }
02156 
02164     ConnectionInterfaceRequestsInterface(
02165         const QString& busName,
02166         const QString& objectPath,
02167         QObject* parent = 0
02168     );
02169 
02178     ConnectionInterfaceRequestsInterface(
02179         const QDBusConnection& connection,
02180         const QString& busName,
02181         const QString& objectPath,
02182         QObject* parent = 0
02183     );
02184 
02191     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
02192 
02200     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02201 
02209     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02210 
02217     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
02218 
02219     
02227     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
02228     {
02229         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
02230     }
02231 
02255     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
02256 
02257     
02265     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
02266     {
02267         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
02268     }
02269 
02270 public Q_SLOTS:
02339     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
02340     {
02341         if (!invalidationReason().isEmpty()) {
02342             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
02343                 invalidationReason(),
02344                 invalidationMessage()
02345             ));
02346         }
02347 
02348 
02349         QList<QVariant> argumentList;
02350         argumentList << QVariant::fromValue(request);
02351         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
02352     }
02353 
02405     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
02406     {
02407         if (!invalidationReason().isEmpty()) {
02408             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
02409                 invalidationReason(),
02410                 invalidationMessage()
02411             ));
02412         }
02413 
02414 
02415         QList<QVariant> argumentList;
02416         argumentList << QVariant::fromValue(request);
02417         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
02418     }
02419 
02420 Q_SIGNALS:
02462     void NewChannels(const Tp::ChannelDetailsList& channels);
02463 
02476     void ChannelClosed(const QDBusObjectPath& removed);
02477 
02478 protected:
02479     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02480 };
02481 
02489 class ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
02490 {
02491     Q_OBJECT
02492 
02493 public:
02500     static inline const char *staticInterfaceName()
02501     {
02502         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
02503     }
02504 
02512     ConnectionInterfaceSimplePresenceInterface(
02513         const QString& busName,
02514         const QString& objectPath,
02515         QObject* parent = 0
02516     );
02517 
02526     ConnectionInterfaceSimplePresenceInterface(
02527         const QDBusConnection& connection,
02528         const QString& busName,
02529         const QString& objectPath,
02530         QObject* parent = 0
02531     );
02532 
02539     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
02540 
02548     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
02549 
02557     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02558 
02594     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
02595 
02596     
02604     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
02605     {
02606         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
02607     }
02608 
02609 public Q_SLOTS:
02664     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
02665     {
02666         if (!invalidationReason().isEmpty()) {
02667             return QDBusPendingReply<>(QDBusMessage::createError(
02668                 invalidationReason(),
02669                 invalidationMessage()
02670             ));
02671         }
02672 
02673 
02674         QList<QVariant> argumentList;
02675         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
02676         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
02677     }
02678 
02703     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
02704     {
02705         if (!invalidationReason().isEmpty()) {
02706             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
02707                 invalidationReason(),
02708                 invalidationMessage()
02709             ));
02710         }
02711 
02712 
02713         QList<QVariant> argumentList;
02714         argumentList << QVariant::fromValue(contacts);
02715         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
02716     }
02717 
02718 Q_SIGNALS:
02731     void PresencesChanged(const Tp::SimpleContactPresences& presence);
02732 
02733 protected:
02734     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02735 };
02736 }
02737 }


Copyright © 2009 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.1.10