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*)


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