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 ConnectionInterfaceContactInfoInterface : public Tp::AbstractInterface
01889 {
01890     Q_OBJECT
01891 
01892 public:
01899     static inline const char *staticInterfaceName()
01900     {
01901         return "org.freedesktop.Telepathy.Connection.Interface.ContactInfo";
01902     }
01903 
01911     ConnectionInterfaceContactInfoInterface(
01912         const QString& busName,
01913         const QString& objectPath,
01914         QObject* parent = 0
01915     );
01916 
01925     ConnectionInterfaceContactInfoInterface(
01926         const QDBusConnection& connection,
01927         const QString& busName,
01928         const QString& objectPath,
01929         QObject* parent = 0
01930     );
01931 
01938     ConnectionInterfaceContactInfoInterface(Tp::DBusProxy *proxy);
01939 
01947     explicit ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface);
01948 
01956     ConnectionInterfaceContactInfoInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
01957 
01975     Q_PROPERTY(uint ContactInfoFlags READ ContactInfoFlags)
01976 
01977     
01985     inline uint ContactInfoFlags() const TELEPATHY_GNUC_DEPRECATED
01986     {
01987         return qvariant_cast<uint>(internalPropGet("ContactInfoFlags"));
01988     }
01989 
02041     Q_PROPERTY(Tp::FieldSpecs SupportedFields READ SupportedFields)
02042 
02043     
02051     inline Tp::FieldSpecs SupportedFields() const TELEPATHY_GNUC_DEPRECATED
02052     {
02053         return qvariant_cast<Tp::FieldSpecs>(internalPropGet("SupportedFields"));
02054     }
02055 
02056 public Q_SLOTS:
02074     inline QDBusPendingReply<Tp::ContactInfoMap> GetContactInfo(const Tp::UIntList& contacts)
02075     {
02076         if (!invalidationReason().isEmpty()) {
02077             return QDBusPendingReply<Tp::ContactInfoMap>(QDBusMessage::createError(
02078                 invalidationReason(),
02079                 invalidationMessage()
02080             ));
02081         }
02082 
02083 
02084         QList<QVariant> argumentList;
02085         argumentList << QVariant::fromValue(contacts);
02086         return asyncCallWithArgumentList(QLatin1String("GetContactInfo"), argumentList);
02087     }
02088 
02103     inline QDBusPendingReply<> RefreshContactInfo(const Tp::UIntList& contacts)
02104     {
02105         if (!invalidationReason().isEmpty()) {
02106             return QDBusPendingReply<>(QDBusMessage::createError(
02107                 invalidationReason(),
02108                 invalidationMessage()
02109             ));
02110         }
02111 
02112 
02113         QList<QVariant> argumentList;
02114         argumentList << QVariant::fromValue(contacts);
02115         return asyncCallWithArgumentList(QLatin1String("RefreshContactInfo"), argumentList);
02116     }
02117 
02134     inline QDBusPendingReply<Tp::ContactInfoFieldList> RequestContactInfo(uint contact)
02135     {
02136         if (!invalidationReason().isEmpty()) {
02137             return QDBusPendingReply<Tp::ContactInfoFieldList>(QDBusMessage::createError(
02138                 invalidationReason(),
02139                 invalidationMessage()
02140             ));
02141         }
02142 
02143 
02144         QList<QVariant> argumentList;
02145         argumentList << QVariant::fromValue(contact);
02146         return asyncCallWithArgumentList(QLatin1String("RequestContactInfo"), argumentList);
02147     }
02148 
02161     inline QDBusPendingReply<> SetContactInfo(const Tp::ContactInfoFieldList& contactInfo)
02162     {
02163         if (!invalidationReason().isEmpty()) {
02164             return QDBusPendingReply<>(QDBusMessage::createError(
02165                 invalidationReason(),
02166                 invalidationMessage()
02167             ));
02168         }
02169 
02170 
02171         QList<QVariant> argumentList;
02172         argumentList << QVariant::fromValue(contactInfo);
02173         return asyncCallWithArgumentList(QLatin1String("SetContactInfo"), argumentList);
02174     }
02175 
02176 Q_SIGNALS:
02191     void ContactInfoChanged(uint contact, const Tp::ContactInfoFieldList& contactInfo);
02192 
02193 protected:
02194     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02195 };
02196 
02204 class TELEPATHY_QT4_EXPORT ConnectionInterfaceContactsInterface : public Tp::AbstractInterface
02205 {
02206     Q_OBJECT
02207 
02208 public:
02215     static inline const char *staticInterfaceName()
02216     {
02217         return "org.freedesktop.Telepathy.Connection.Interface.Contacts";
02218     }
02219 
02227     ConnectionInterfaceContactsInterface(
02228         const QString& busName,
02229         const QString& objectPath,
02230         QObject* parent = 0
02231     );
02232 
02241     ConnectionInterfaceContactsInterface(
02242         const QDBusConnection& connection,
02243         const QString& busName,
02244         const QString& objectPath,
02245         QObject* parent = 0
02246     );
02247 
02254     ConnectionInterfaceContactsInterface(Tp::DBusProxy *proxy);
02255 
02263     explicit ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface);
02264 
02272     ConnectionInterfaceContactsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02273 
02280     Q_PROPERTY(QStringList ContactAttributeInterfaces READ ContactAttributeInterfaces)
02281 
02282     
02290     inline QStringList ContactAttributeInterfaces() const TELEPATHY_GNUC_DEPRECATED
02291     {
02292         return qvariant_cast<QStringList>(internalPropGet("ContactAttributeInterfaces"));
02293     }
02294 
02295 public Q_SLOTS:
02361     inline QDBusPendingReply<Tp::ContactAttributesMap> GetContactAttributes(const Tp::UIntList& handles, const QStringList& interfaces, bool hold)
02362     {
02363         if (!invalidationReason().isEmpty()) {
02364             return QDBusPendingReply<Tp::ContactAttributesMap>(QDBusMessage::createError(
02365                 invalidationReason(),
02366                 invalidationMessage()
02367             ));
02368         }
02369 
02370 
02371         QList<QVariant> argumentList;
02372         argumentList << QVariant::fromValue(handles) << QVariant::fromValue(interfaces) << QVariant::fromValue(hold);
02373         return asyncCallWithArgumentList(QLatin1String("GetContactAttributes"), argumentList);
02374     }
02375 
02376 protected:
02377     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02378 };
02379 
02387 class TELEPATHY_QT4_EXPORT ConnectionInterfaceLocationInterface : public Tp::AbstractInterface
02388 {
02389     Q_OBJECT
02390 
02391 public:
02398     static inline const char *staticInterfaceName()
02399     {
02400         return "org.freedesktop.Telepathy.Connection.Interface.Location";
02401     }
02402 
02410     ConnectionInterfaceLocationInterface(
02411         const QString& busName,
02412         const QString& objectPath,
02413         QObject* parent = 0
02414     );
02415 
02424     ConnectionInterfaceLocationInterface(
02425         const QDBusConnection& connection,
02426         const QString& busName,
02427         const QString& objectPath,
02428         QObject* parent = 0
02429     );
02430 
02437     ConnectionInterfaceLocationInterface(Tp::DBusProxy *proxy);
02438 
02446     explicit ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface);
02447 
02455     ConnectionInterfaceLocationInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02456 
02462     Q_PROPERTY(Tp::UIntList LocationAccessControlTypes READ LocationAccessControlTypes)
02463 
02464     
02472     inline Tp::UIntList LocationAccessControlTypes() const TELEPATHY_GNUC_DEPRECATED
02473     {
02474         return qvariant_cast<Tp::UIntList>(internalPropGet("LocationAccessControlTypes"));
02475     }
02476 
02485     Q_PROPERTY(Tp::RichPresenceAccessControl LocationAccessControl READ LocationAccessControl WRITE setLocationAccessControl)
02486 
02487     
02495     inline Tp::RichPresenceAccessControl LocationAccessControl() const TELEPATHY_GNUC_DEPRECATED
02496     {
02497         return qvariant_cast<Tp::RichPresenceAccessControl>(internalPropGet("LocationAccessControl"));
02498     }
02499 
02507     inline void setLocationAccessControl(const Tp::RichPresenceAccessControl& newValue) TELEPATHY_GNUC_DEPRECATED
02508     {
02509         internalPropSet("LocationAccessControl", QVariant::fromValue(newValue));
02510     }
02511 
02512 public Q_SLOTS:
02536     inline QDBusPendingReply<Tp::ContactLocations> GetLocations(const Tp::UIntList& contacts)
02537     {
02538         if (!invalidationReason().isEmpty()) {
02539             return QDBusPendingReply<Tp::ContactLocations>(QDBusMessage::createError(
02540                 invalidationReason(),
02541                 invalidationMessage()
02542             ));
02543         }
02544 
02545 
02546         QList<QVariant> argumentList;
02547         argumentList << QVariant::fromValue(contacts);
02548         return asyncCallWithArgumentList(QLatin1String("GetLocations"), argumentList);
02549     }
02550 
02570     inline QDBusPendingReply<QVariantMap> RequestLocation(uint contact)
02571     {
02572         if (!invalidationReason().isEmpty()) {
02573             return QDBusPendingReply<QVariantMap>(QDBusMessage::createError(
02574                 invalidationReason(),
02575                 invalidationMessage()
02576             ));
02577         }
02578 
02579 
02580         QList<QVariant> argumentList;
02581         argumentList << QVariant::fromValue(contact);
02582         return asyncCallWithArgumentList(QLatin1String("RequestLocation"), argumentList);
02583     }
02584 
02601     inline QDBusPendingReply<> SetLocation(const QVariantMap& location)
02602     {
02603         if (!invalidationReason().isEmpty()) {
02604             return QDBusPendingReply<>(QDBusMessage::createError(
02605                 invalidationReason(),
02606                 invalidationMessage()
02607             ));
02608         }
02609 
02610 
02611         QList<QVariant> argumentList;
02612         argumentList << QVariant::fromValue(location);
02613         return asyncCallWithArgumentList(QLatin1String("SetLocation"), argumentList);
02614     }
02615 
02616 Q_SIGNALS:
02631     void LocationUpdated(uint contact, const QVariantMap& location);
02632 
02633 protected:
02634     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02635 };
02636 
02644 class TELEPATHY_QT4_EXPORT ConnectionInterfacePresenceInterface : public Tp::AbstractInterface
02645 {
02646     Q_OBJECT
02647 
02648 public:
02655     static inline const char *staticInterfaceName()
02656     {
02657         return "org.freedesktop.Telepathy.Connection.Interface.Presence";
02658     }
02659 
02667     ConnectionInterfacePresenceInterface(
02668         const QString& busName,
02669         const QString& objectPath,
02670         QObject* parent = 0
02671     );
02672 
02681     ConnectionInterfacePresenceInterface(
02682         const QDBusConnection& connection,
02683         const QString& busName,
02684         const QString& objectPath,
02685         QObject* parent = 0
02686     );
02687 
02694     ConnectionInterfacePresenceInterface(Tp::DBusProxy *proxy);
02695 
02703     explicit ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
02704 
02712     ConnectionInterfacePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
02713 
02714 public Q_SLOTS:
02731     inline QDBusPendingReply<> AddStatus(const QString& status, const QVariantMap& parameters)
02732     {
02733         if (!invalidationReason().isEmpty()) {
02734             return QDBusPendingReply<>(QDBusMessage::createError(
02735                 invalidationReason(),
02736                 invalidationMessage()
02737             ));
02738         }
02739 
02740 
02741         QList<QVariant> argumentList;
02742         argumentList << QVariant::fromValue(status) << QVariant::fromValue(parameters);
02743         return asyncCallWithArgumentList(QLatin1String("AddStatus"), argumentList);
02744     }
02745 
02754     inline QDBusPendingReply<> ClearStatus()
02755     {
02756         if (!invalidationReason().isEmpty()) {
02757             return QDBusPendingReply<>(QDBusMessage::createError(
02758                 invalidationReason(),
02759                 invalidationMessage()
02760             ));
02761         }
02762 
02763 
02764         return asyncCall(QLatin1String("ClearStatus"));
02765     }
02766 
02785     inline QDBusPendingReply<Tp::ContactPresences> GetPresence(const Tp::UIntList& contacts)
02786     {
02787         if (!invalidationReason().isEmpty()) {
02788             return QDBusPendingReply<Tp::ContactPresences>(QDBusMessage::createError(
02789                 invalidationReason(),
02790                 invalidationMessage()
02791             ));
02792         }
02793 
02794 
02795         QList<QVariant> argumentList;
02796         argumentList << QVariant::fromValue(contacts);
02797         return asyncCallWithArgumentList(QLatin1String("GetPresence"), argumentList);
02798     }
02799 
02816     inline QDBusPendingReply<Tp::StatusSpecMap> GetStatuses()
02817     {
02818         if (!invalidationReason().isEmpty()) {
02819             return QDBusPendingReply<Tp::StatusSpecMap>(QDBusMessage::createError(
02820                 invalidationReason(),
02821                 invalidationMessage()
02822             ));
02823         }
02824 
02825 
02826         return asyncCall(QLatin1String("GetStatuses"));
02827     }
02828 
02842     inline QDBusPendingReply<> RemoveStatus(const QString& status)
02843     {
02844         if (!invalidationReason().isEmpty()) {
02845             return QDBusPendingReply<>(QDBusMessage::createError(
02846                 invalidationReason(),
02847                 invalidationMessage()
02848             ));
02849         }
02850 
02851 
02852         QList<QVariant> argumentList;
02853         argumentList << QVariant::fromValue(status);
02854         return asyncCallWithArgumentList(QLatin1String("RemoveStatus"), argumentList);
02855     }
02856 
02870     inline QDBusPendingReply<> RequestPresence(const Tp::UIntList& contacts)
02871     {
02872         if (!invalidationReason().isEmpty()) {
02873             return QDBusPendingReply<>(QDBusMessage::createError(
02874                 invalidationReason(),
02875                 invalidationMessage()
02876             ));
02877         }
02878 
02879 
02880         QList<QVariant> argumentList;
02881         argumentList << QVariant::fromValue(contacts);
02882         return asyncCallWithArgumentList(QLatin1String("RequestPresence"), argumentList);
02883     }
02884 
02895     inline QDBusPendingReply<> SetLastActivityTime(uint time)
02896     {
02897         if (!invalidationReason().isEmpty()) {
02898             return QDBusPendingReply<>(QDBusMessage::createError(
02899                 invalidationReason(),
02900                 invalidationMessage()
02901             ));
02902         }
02903 
02904 
02905         QList<QVariant> argumentList;
02906         argumentList << QVariant::fromValue(time);
02907         return asyncCallWithArgumentList(QLatin1String("SetLastActivityTime"), argumentList);
02908     }
02909 
02940     inline QDBusPendingReply<> SetStatus(const Tp::MultipleStatusMap& statuses)
02941     {
02942         if (!invalidationReason().isEmpty()) {
02943             return QDBusPendingReply<>(QDBusMessage::createError(
02944                 invalidationReason(),
02945                 invalidationMessage()
02946             ));
02947         }
02948 
02949 
02950         QList<QVariant> argumentList;
02951         argumentList << QVariant::fromValue(statuses);
02952         return asyncCallWithArgumentList(QLatin1String("SetStatus"), argumentList);
02953     }
02954 
02955 Q_SIGNALS:
02972     void PresenceUpdate(const Tp::ContactPresences& presence);
02973 
02974 protected:
02975     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02976 };
02977 
02985 class TELEPATHY_QT4_EXPORT ConnectionInterfaceRequestsInterface : public Tp::AbstractInterface
02986 {
02987     Q_OBJECT
02988 
02989 public:
02996     static inline const char *staticInterfaceName()
02997     {
02998         return "org.freedesktop.Telepathy.Connection.Interface.Requests";
02999     }
03000 
03008     ConnectionInterfaceRequestsInterface(
03009         const QString& busName,
03010         const QString& objectPath,
03011         QObject* parent = 0
03012     );
03013 
03022     ConnectionInterfaceRequestsInterface(
03023         const QDBusConnection& connection,
03024         const QString& busName,
03025         const QString& objectPath,
03026         QObject* parent = 0
03027     );
03028 
03035     ConnectionInterfaceRequestsInterface(Tp::DBusProxy *proxy);
03036 
03044     explicit ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface);
03045 
03053     ConnectionInterfaceRequestsInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03054 
03061     Q_PROPERTY(Tp::ChannelDetailsList Channels READ Channels)
03062 
03063     
03071     inline Tp::ChannelDetailsList Channels() const TELEPATHY_GNUC_DEPRECATED
03072     {
03073         return qvariant_cast<Tp::ChannelDetailsList>(internalPropGet("Channels"));
03074     }
03075 
03099     Q_PROPERTY(Tp::RequestableChannelClassList RequestableChannelClasses READ RequestableChannelClasses)
03100 
03101     
03109     inline Tp::RequestableChannelClassList RequestableChannelClasses() const TELEPATHY_GNUC_DEPRECATED
03110     {
03111         return qvariant_cast<Tp::RequestableChannelClassList>(internalPropGet("RequestableChannelClasses"));
03112     }
03113 
03114 public Q_SLOTS:
03183     inline QDBusPendingReply<QDBusObjectPath, QVariantMap> CreateChannel(const QVariantMap& request)
03184     {
03185         if (!invalidationReason().isEmpty()) {
03186             return QDBusPendingReply<QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03187                 invalidationReason(),
03188                 invalidationMessage()
03189             ));
03190         }
03191 
03192 
03193         QList<QVariant> argumentList;
03194         argumentList << QVariant::fromValue(request);
03195         return asyncCallWithArgumentList(QLatin1String("CreateChannel"), argumentList);
03196     }
03197 
03249     inline QDBusPendingReply<bool, QDBusObjectPath, QVariantMap> EnsureChannel(const QVariantMap& request)
03250     {
03251         if (!invalidationReason().isEmpty()) {
03252             return QDBusPendingReply<bool, QDBusObjectPath, QVariantMap>(QDBusMessage::createError(
03253                 invalidationReason(),
03254                 invalidationMessage()
03255             ));
03256         }
03257 
03258 
03259         QList<QVariant> argumentList;
03260         argumentList << QVariant::fromValue(request);
03261         return asyncCallWithArgumentList(QLatin1String("EnsureChannel"), argumentList);
03262     }
03263 
03264 Q_SIGNALS:
03306     void NewChannels(const Tp::ChannelDetailsList& channels);
03307 
03320     void ChannelClosed(const QDBusObjectPath& removed);
03321 
03322 protected:
03323     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03324 };
03325 
03333 class TELEPATHY_QT4_EXPORT ConnectionInterfaceSimplePresenceInterface : public Tp::AbstractInterface
03334 {
03335     Q_OBJECT
03336 
03337 public:
03344     static inline const char *staticInterfaceName()
03345     {
03346         return "org.freedesktop.Telepathy.Connection.Interface.SimplePresence";
03347     }
03348 
03356     ConnectionInterfaceSimplePresenceInterface(
03357         const QString& busName,
03358         const QString& objectPath,
03359         QObject* parent = 0
03360     );
03361 
03370     ConnectionInterfaceSimplePresenceInterface(
03371         const QDBusConnection& connection,
03372         const QString& busName,
03373         const QString& objectPath,
03374         QObject* parent = 0
03375     );
03376 
03383     ConnectionInterfaceSimplePresenceInterface(Tp::DBusProxy *proxy);
03384 
03392     explicit ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface);
03393 
03401     ConnectionInterfaceSimplePresenceInterface(const Tp::Client::ConnectionInterface& mainInterface, QObject* parent);
03402 
03438     Q_PROPERTY(Tp::SimpleStatusSpecMap Statuses READ Statuses)
03439 
03440     
03448     inline Tp::SimpleStatusSpecMap Statuses() const TELEPATHY_GNUC_DEPRECATED
03449     {
03450         return qvariant_cast<Tp::SimpleStatusSpecMap>(internalPropGet("Statuses"));
03451     }
03452 
03453 public Q_SLOTS:
03508     inline QDBusPendingReply<> SetPresence(const QString& status, const QString& statusMessage)
03509     {
03510         if (!invalidationReason().isEmpty()) {
03511             return QDBusPendingReply<>(QDBusMessage::createError(
03512                 invalidationReason(),
03513                 invalidationMessage()
03514             ));
03515         }
03516 
03517 
03518         QList<QVariant> argumentList;
03519         argumentList << QVariant::fromValue(status) << QVariant::fromValue(statusMessage);
03520         return asyncCallWithArgumentList(QLatin1String("SetPresence"), argumentList);
03521     }
03522 
03547     inline QDBusPendingReply<Tp::SimpleContactPresences> GetPresences(const Tp::UIntList& contacts)
03548     {
03549         if (!invalidationReason().isEmpty()) {
03550             return QDBusPendingReply<Tp::SimpleContactPresences>(QDBusMessage::createError(
03551                 invalidationReason(),
03552                 invalidationMessage()
03553             ));
03554         }
03555 
03556 
03557         QList<QVariant> argumentList;
03558         argumentList << QVariant::fromValue(contacts);
03559         return asyncCallWithArgumentList(QLatin1String("GetPresences"), argumentList);
03560     }
03561 
03562 Q_SIGNALS:
03575     void PresencesChanged(const Tp::SimpleContactPresences& presence);
03576 
03577 protected:
03578     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03579 };
03580 }
03581 }
03582 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterface*)
03583 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAliasingInterface*)
03584 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceAvatarsInterface*)
03585 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceCapabilitiesInterface*)
03586 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactCapabilitiesInterface*)
03587 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactInfoInterface*)
03588 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceContactsInterface*)
03589 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceLocationInterface*)
03590 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfacePresenceInterface*)
03591 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceRequestsInterface*)
03592 Q_DECLARE_METATYPE(Tp::Client::ConnectionInterfaceSimplePresenceInterface*)


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