Home · All Classes · All Namespaces · Modules · Functions · Files

cli-channel.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 ChannelInterface : public Tp::AbstractInterface
00047 {
00048     Q_OBJECT
00049 
00050 public:
00057     static inline const char *staticInterfaceName()
00058     {
00059         return "org.freedesktop.Telepathy.Channel";
00060     }
00061 
00069     ChannelInterface(
00070         const QString& busName,
00071         const QString& objectPath,
00072         QObject* parent = 0
00073     );
00074 
00083     ChannelInterface(
00084         const QDBusConnection& connection,
00085         const QString& busName,
00086         const QString& objectPath,
00087         QObject* parent = 0
00088     );
00089 
00096     ChannelInterface(Tp::DBusProxy *proxy);
00097 
00122     Q_PROPERTY(QString ChannelType READ ChannelType)
00123 
00124     
00132     inline QString ChannelType() const TELEPATHY_GNUC_DEPRECATED
00133     {
00134         return qvariant_cast<QString>(internalPropGet("ChannelType"));
00135     }
00136 
00164     Q_PROPERTY(QStringList Interfaces READ Interfaces)
00165 
00166     
00174     inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
00175     {
00176         return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
00177     }
00178 
00215     Q_PROPERTY(uint TargetHandle READ TargetHandle)
00216 
00217     
00225     inline uint TargetHandle() const TELEPATHY_GNUC_DEPRECATED
00226     {
00227         return qvariant_cast<uint>(internalPropGet("TargetHandle"));
00228     }
00229 
00274     Q_PROPERTY(QString TargetID READ TargetID)
00275 
00276     
00284     inline QString TargetID() const TELEPATHY_GNUC_DEPRECATED
00285     {
00286         return qvariant_cast<QString>(internalPropGet("TargetID"));
00287     }
00288 
00302     Q_PROPERTY(uint TargetHandleType READ TargetHandleType)
00303 
00304     
00312     inline uint TargetHandleType() const TELEPATHY_GNUC_DEPRECATED
00313     {
00314         return qvariant_cast<uint>(internalPropGet("TargetHandleType"));
00315     }
00316 
00379     Q_PROPERTY(bool Requested READ Requested)
00380 
00381     
00389     inline bool Requested() const TELEPATHY_GNUC_DEPRECATED
00390     {
00391         return qvariant_cast<bool>(internalPropGet("Requested"));
00392     }
00393 
00449     Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)
00450 
00451     
00459     inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
00460     {
00461         return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
00462     }
00463 
00492     Q_PROPERTY(QString InitiatorID READ InitiatorID)
00493 
00494     
00502     inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
00503     {
00504         return qvariant_cast<QString>(internalPropGet("InitiatorID"));
00505     }
00506 
00507 public Q_SLOTS:
00517     inline QDBusPendingReply<> Close()
00518     {
00519         if (!invalidationReason().isEmpty()) {
00520             return QDBusPendingReply<>(QDBusMessage::createError(
00521                 invalidationReason(),
00522                 invalidationMessage()
00523             ));
00524         }
00525 
00526 
00527         return asyncCall(QLatin1String("Close"));
00528     }
00529 
00542     inline QDBusPendingReply<QString> GetChannelType()
00543     {
00544         if (!invalidationReason().isEmpty()) {
00545             return QDBusPendingReply<QString>(QDBusMessage::createError(
00546                 invalidationReason(),
00547                 invalidationMessage()
00548             ));
00549         }
00550 
00551 
00552         return asyncCall(QLatin1String("GetChannelType"));
00553     }
00554 
00573     inline QDBusPendingReply<uint, uint> GetHandle()
00574     {
00575         if (!invalidationReason().isEmpty()) {
00576             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00577                 invalidationReason(),
00578                 invalidationMessage()
00579             ));
00580         }
00581 
00582 
00583         return asyncCall(QLatin1String("GetHandle"));
00584     }
00585 
00598     inline QDBusPendingReply<QStringList> GetInterfaces()
00599     {
00600         if (!invalidationReason().isEmpty()) {
00601             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00602                 invalidationReason(),
00603                 invalidationMessage()
00604             ));
00605         }
00606 
00607 
00608         return asyncCall(QLatin1String("GetInterfaces"));
00609     }
00610 
00611 Q_SIGNALS:
00619     void Closed();
00620 
00621 protected:
00622     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00623 };
00624 
00632 class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
00633 {
00634     Q_OBJECT
00635 
00636 public:
00643     static inline const char *staticInterfaceName()
00644     {
00645         return "org.freedesktop.Telepathy.Channel.Interface.Anonymity";
00646     }
00647 
00655     ChannelInterfaceAnonymityInterface(
00656         const QString& busName,
00657         const QString& objectPath,
00658         QObject* parent = 0
00659     );
00660 
00669     ChannelInterfaceAnonymityInterface(
00670         const QDBusConnection& connection,
00671         const QString& busName,
00672         const QString& objectPath,
00673         QObject* parent = 0
00674     );
00675 
00682     ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00683 
00691     explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);
00692 
00700     ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00701 
00708     Q_PROPERTY(uint AnonymityModes READ AnonymityModes)
00709 
00710     
00718     inline uint AnonymityModes() const TELEPATHY_GNUC_DEPRECATED
00719     {
00720         return qvariant_cast<uint>(internalPropGet("AnonymityModes"));
00721     }
00722 
00729     Q_PROPERTY(bool AnonymityMandatory READ AnonymityMandatory)
00730 
00731     
00739     inline bool AnonymityMandatory() const TELEPATHY_GNUC_DEPRECATED
00740     {
00741         return qvariant_cast<bool>(internalPropGet("AnonymityMandatory"));
00742     }
00743 
00759     Q_PROPERTY(QString AnonymousID READ AnonymousID)
00760 
00761     
00769     inline QString AnonymousID() const TELEPATHY_GNUC_DEPRECATED
00770     {
00771         return qvariant_cast<QString>(internalPropGet("AnonymousID"));
00772     }
00773 
00774 protected:
00775     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00776 };
00777 
00785 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00786 {
00787     Q_OBJECT
00788 
00789 public:
00796     static inline const char *staticInterfaceName()
00797     {
00798         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
00799     }
00800 
00808     ChannelInterfaceCallStateInterface(
00809         const QString& busName,
00810         const QString& objectPath,
00811         QObject* parent = 0
00812     );
00813 
00822     ChannelInterfaceCallStateInterface(
00823         const QDBusConnection& connection,
00824         const QString& busName,
00825         const QString& objectPath,
00826         QObject* parent = 0
00827     );
00828 
00835     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00836 
00844     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00845 
00853     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00854 
00855 public Q_SLOTS:
00866     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
00867     {
00868         if (!invalidationReason().isEmpty()) {
00869             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00870                 invalidationReason(),
00871                 invalidationMessage()
00872             ));
00873         }
00874 
00875 
00876         return asyncCall(QLatin1String("GetCallStates"));
00877     }
00878 
00879 Q_SIGNALS:
00893     void CallStateChanged(uint contact, uint state);
00894 
00895 protected:
00896     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00897 };
00898 
00906 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00907 {
00908     Q_OBJECT
00909 
00910 public:
00917     static inline const char *staticInterfaceName()
00918     {
00919         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
00920     }
00921 
00929     ChannelInterfaceChatStateInterface(
00930         const QString& busName,
00931         const QString& objectPath,
00932         QObject* parent = 0
00933     );
00934 
00943     ChannelInterfaceChatStateInterface(
00944         const QDBusConnection& connection,
00945         const QString& busName,
00946         const QString& objectPath,
00947         QObject* parent = 0
00948     );
00949 
00956     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00957 
00965     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00966 
00974     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00975 
01005     Q_PROPERTY(Tp::ChatStateMap ChatStates READ ChatStates)
01006 
01007     
01015     inline Tp::ChatStateMap ChatStates() const TELEPATHY_GNUC_DEPRECATED
01016     {
01017         return qvariant_cast<Tp::ChatStateMap>(internalPropGet("ChatStates"));
01018     }
01019 
01020 public Q_SLOTS:
01031     inline QDBusPendingReply<> SetChatState(uint state)
01032     {
01033         if (!invalidationReason().isEmpty()) {
01034             return QDBusPendingReply<>(QDBusMessage::createError(
01035                 invalidationReason(),
01036                 invalidationMessage()
01037             ));
01038         }
01039 
01040 
01041         QList<QVariant> argumentList;
01042         argumentList << QVariant::fromValue(state);
01043         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
01044     }
01045 
01046 Q_SIGNALS:
01061     void ChatStateChanged(uint contact, uint state);
01062 
01063 protected:
01064     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01065 };
01066 
01074 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01075 {
01076     Q_OBJECT
01077 
01078 public:
01085     static inline const char *staticInterfaceName()
01086     {
01087         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
01088     }
01089 
01097     ChannelInterfaceDTMFInterface(
01098         const QString& busName,
01099         const QString& objectPath,
01100         QObject* parent = 0
01101     );
01102 
01111     ChannelInterfaceDTMFInterface(
01112         const QDBusConnection& connection,
01113         const QString& busName,
01114         const QString& objectPath,
01115         QObject* parent = 0
01116     );
01117 
01124     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01125 
01133     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01134 
01142     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01143 
01151     Q_PROPERTY(bool CurrentlySendingTones READ CurrentlySendingTones)
01152 
01153     
01161     inline bool CurrentlySendingTones() const TELEPATHY_GNUC_DEPRECATED
01162     {
01163         return qvariant_cast<bool>(internalPropGet("CurrentlySendingTones"));
01164     }
01165 
01174     Q_PROPERTY(QString InitialTones READ InitialTones)
01175 
01176     
01184     inline QString InitialTones() const TELEPATHY_GNUC_DEPRECATED
01185     {
01186         return qvariant_cast<QString>(internalPropGet("InitialTones"));
01187     }
01188 
01189 public Q_SLOTS:
01215     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
01216     {
01217         if (!invalidationReason().isEmpty()) {
01218             return QDBusPendingReply<>(QDBusMessage::createError(
01219                 invalidationReason(),
01220                 invalidationMessage()
01221             ));
01222         }
01223 
01224 
01225         QList<QVariant> argumentList;
01226         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01227         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
01228     }
01229 
01247     inline QDBusPendingReply<> StopTone(uint streamID)
01248     {
01249         if (!invalidationReason().isEmpty()) {
01250             return QDBusPendingReply<>(QDBusMessage::createError(
01251                 invalidationReason(),
01252                 invalidationMessage()
01253             ));
01254         }
01255 
01256 
01257         QList<QVariant> argumentList;
01258         argumentList << QVariant::fromValue(streamID);
01259         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
01260     }
01261 
01280     inline QDBusPendingReply<> MultipleTones(const QString& tones)
01281     {
01282         if (!invalidationReason().isEmpty()) {
01283             return QDBusPendingReply<>(QDBusMessage::createError(
01284                 invalidationReason(),
01285                 invalidationMessage()
01286             ));
01287         }
01288 
01289 
01290         QList<QVariant> argumentList;
01291         argumentList << QVariant::fromValue(tones);
01292         return asyncCallWithArgumentList(QLatin1String("MultipleTones"), argumentList);
01293     }
01294 
01295 Q_SIGNALS:
01310     void SendingTones(const QString& tones);
01311 
01321     void StoppedTones(bool cancelled);
01322 
01323 protected:
01324     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01325 };
01326 
01334 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01335 {
01336     Q_OBJECT
01337 
01338 public:
01345     static inline const char *staticInterfaceName()
01346     {
01347         return "org.freedesktop.Telepathy.Channel.Interface.Group";
01348     }
01349 
01357     ChannelInterfaceGroupInterface(
01358         const QString& busName,
01359         const QString& objectPath,
01360         QObject* parent = 0
01361     );
01362 
01371     ChannelInterfaceGroupInterface(
01372         const QDBusConnection& connection,
01373         const QString& busName,
01374         const QString& objectPath,
01375         QObject* parent = 0
01376     );
01377 
01384     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01385 
01393     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01394 
01402     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01403 
01412     Q_PROPERTY(uint GroupFlags READ GroupFlags)
01413 
01414     
01422     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
01423     {
01424         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
01425     }
01426 
01438     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
01439 
01440     
01448     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01449     {
01450         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
01451     }
01452 
01459     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01460 
01461     
01469     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01470     {
01471         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01472     }
01473 
01479     Q_PROPERTY(Tp::UIntList Members READ Members)
01480 
01481     
01489     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01490     {
01491         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
01492     }
01493 
01500     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
01501 
01502     
01510     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01511     {
01512         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
01513     }
01514 
01525     Q_PROPERTY(uint SelfHandle READ SelfHandle)
01526 
01527     
01535     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
01536     {
01537         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
01538     }
01539 
01540 public Q_SLOTS:
01564     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
01565     {
01566         if (!invalidationReason().isEmpty()) {
01567             return QDBusPendingReply<>(QDBusMessage::createError(
01568                 invalidationReason(),
01569                 invalidationMessage()
01570             ));
01571         }
01572 
01573 
01574         QList<QVariant> argumentList;
01575         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01576         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
01577     }
01578 
01596     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
01597     {
01598         if (!invalidationReason().isEmpty()) {
01599             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
01600                 invalidationReason(),
01601                 invalidationMessage()
01602             ));
01603         }
01604 
01605 
01606         return asyncCall(QLatin1String("GetAllMembers"));
01607     }
01608 
01618     inline QDBusPendingReply<uint> GetGroupFlags()
01619     {
01620         if (!invalidationReason().isEmpty()) {
01621             return QDBusPendingReply<uint>(QDBusMessage::createError(
01622                 invalidationReason(),
01623                 invalidationMessage()
01624             ));
01625         }
01626 
01627 
01628         return asyncCall(QLatin1String("GetGroupFlags"));
01629     }
01630 
01651     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
01652     {
01653         if (!invalidationReason().isEmpty()) {
01654             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01655                 invalidationReason(),
01656                 invalidationMessage()
01657             ));
01658         }
01659 
01660 
01661         QList<QVariant> argumentList;
01662         argumentList << QVariant::fromValue(handles);
01663         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
01664     }
01665 
01672     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
01673     {
01674         if (!invalidationReason().isEmpty()) {
01675             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01676                 invalidationReason(),
01677                 invalidationMessage()
01678             ));
01679         }
01680 
01681 
01682         return asyncCall(QLatin1String("GetLocalPendingMembers"));
01683     }
01684 
01698     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
01699     {
01700         if (!invalidationReason().isEmpty()) {
01701             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
01702                 invalidationReason(),
01703                 invalidationMessage()
01704             ));
01705         }
01706 
01707 
01708         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
01709     }
01710 
01716     inline QDBusPendingReply<Tp::UIntList> GetMembers()
01717     {
01718         if (!invalidationReason().isEmpty()) {
01719             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01720                 invalidationReason(),
01721                 invalidationMessage()
01722             ));
01723         }
01724 
01725 
01726         return asyncCall(QLatin1String("GetMembers"));
01727     }
01728 
01735     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
01736     {
01737         if (!invalidationReason().isEmpty()) {
01738             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01739                 invalidationReason(),
01740                 invalidationMessage()
01741             ));
01742         }
01743 
01744 
01745         return asyncCall(QLatin1String("GetRemotePendingMembers"));
01746     }
01747 
01753     inline QDBusPendingReply<uint> GetSelfHandle()
01754     {
01755         if (!invalidationReason().isEmpty()) {
01756             return QDBusPendingReply<uint>(QDBusMessage::createError(
01757                 invalidationReason(),
01758                 invalidationMessage()
01759             ));
01760         }
01761 
01762 
01763         return asyncCall(QLatin1String("GetSelfHandle"));
01764     }
01765 
01814     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
01815     {
01816         if (!invalidationReason().isEmpty()) {
01817             return QDBusPendingReply<>(QDBusMessage::createError(
01818                 invalidationReason(),
01819                 invalidationMessage()
01820             ));
01821         }
01822 
01823 
01824         QList<QVariant> argumentList;
01825         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01826         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
01827     }
01828 
01848     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
01849     {
01850         if (!invalidationReason().isEmpty()) {
01851             return QDBusPendingReply<>(QDBusMessage::createError(
01852                 invalidationReason(),
01853                 invalidationMessage()
01854             ));
01855         }
01856 
01857 
01858         QList<QVariant> argumentList;
01859         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
01860         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
01861     }
01862 
01863 Q_SIGNALS:
01882     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
01883 
01893     void SelfHandleChanged(uint selfHandle);
01894 
01909     void GroupFlagsChanged(uint added, uint removed);
01910 
01962     void MembersChanged(const QString& message, const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, uint actor, uint reason);
01963 
02068     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
02069 
02070 protected:
02071     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02072 };
02073 
02081 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
02082 {
02083     Q_OBJECT
02084 
02085 public:
02092     static inline const char *staticInterfaceName()
02093     {
02094         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
02095     }
02096 
02104     ChannelInterfaceHoldInterface(
02105         const QString& busName,
02106         const QString& objectPath,
02107         QObject* parent = 0
02108     );
02109 
02118     ChannelInterfaceHoldInterface(
02119         const QDBusConnection& connection,
02120         const QString& busName,
02121         const QString& objectPath,
02122         QObject* parent = 0
02123     );
02124 
02131     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
02132 
02140     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
02141 
02149     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02150 
02151 public Q_SLOTS:
02165     inline QDBusPendingReply<uint, uint> GetHoldState()
02166     {
02167         if (!invalidationReason().isEmpty()) {
02168             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02169                 invalidationReason(),
02170                 invalidationMessage()
02171             ));
02172         }
02173 
02174 
02175         return asyncCall(QLatin1String("GetHoldState"));
02176     }
02177 
02234     inline QDBusPendingReply<> RequestHold(bool hold)
02235     {
02236         if (!invalidationReason().isEmpty()) {
02237             return QDBusPendingReply<>(QDBusMessage::createError(
02238                 invalidationReason(),
02239                 invalidationMessage()
02240             ));
02241         }
02242 
02243 
02244         QList<QVariant> argumentList;
02245         argumentList << QVariant::fromValue(hold);
02246         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
02247     }
02248 
02249 Q_SIGNALS:
02266     void HoldStateChanged(uint holdState, uint reason);
02267 
02268 protected:
02269     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02270 };
02271 
02279 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
02280 {
02281     Q_OBJECT
02282 
02283 public:
02290     static inline const char *staticInterfaceName()
02291     {
02292         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
02293     }
02294 
02302     ChannelInterfaceMediaSignallingInterface(
02303         const QString& busName,
02304         const QString& objectPath,
02305         QObject* parent = 0
02306     );
02307 
02316     ChannelInterfaceMediaSignallingInterface(
02317         const QDBusConnection& connection,
02318         const QString& busName,
02319         const QString& objectPath,
02320         QObject* parent = 0
02321     );
02322 
02329     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02330 
02338     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02339 
02347     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02348 
02349 public Q_SLOTS:
02356     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
02357     {
02358         if (!invalidationReason().isEmpty()) {
02359             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02360                 invalidationReason(),
02361                 invalidationMessage()
02362             ));
02363         }
02364 
02365 
02366         return asyncCall(QLatin1String("GetSessionHandlers"));
02367     }
02368 
02369 Q_SIGNALS:
02385     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02386 
02387 protected:
02388     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02389 };
02390 
02398 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02399 {
02400     Q_OBJECT
02401 
02402 public:
02409     static inline const char *staticInterfaceName()
02410     {
02411         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02412     }
02413 
02421     ChannelInterfaceMessagesInterface(
02422         const QString& busName,
02423         const QString& objectPath,
02424         QObject* parent = 0
02425     );
02426 
02435     ChannelInterfaceMessagesInterface(
02436         const QDBusConnection& connection,
02437         const QString& busName,
02438         const QString& objectPath,
02439         QObject* parent = 0
02440     );
02441 
02448     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02449 
02457     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
02458 
02466     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02467 
02513     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02514 
02515     
02523     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02524     {
02525         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02526     }
02527 
02533     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
02534 
02535     
02543     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
02544     {
02545         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
02546     }
02547 
02557     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
02558 
02559     
02567     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
02568     {
02569         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
02570     }
02571 
02577     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
02578 
02579     
02587     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
02588     {
02589         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
02590     }
02591 
02592 public Q_SLOTS:
02634     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
02635     {
02636         if (!invalidationReason().isEmpty()) {
02637             return QDBusPendingReply<QString>(QDBusMessage::createError(
02638                 invalidationReason(),
02639                 invalidationMessage()
02640             ));
02641         }
02642 
02643 
02644         QList<QVariant> argumentList;
02645         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
02646         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
02647     }
02648 
02682     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
02683     {
02684         if (!invalidationReason().isEmpty()) {
02685             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
02686                 invalidationReason(),
02687                 invalidationMessage()
02688             ));
02689         }
02690 
02691 
02692         QList<QVariant> argumentList;
02693         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
02694         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
02695     }
02696 
02697 Q_SIGNALS:
02745     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
02746 
02760     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
02761 
02780     void MessageReceived(const Tp::MessagePartList& message);
02781 
02782 protected:
02783     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02784 };
02785 
02793 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
02794 {
02795     Q_OBJECT
02796 
02797 public:
02804     static inline const char *staticInterfaceName()
02805     {
02806         return "org.freedesktop.Telepathy.Channel.Interface.Password";
02807     }
02808 
02816     ChannelInterfacePasswordInterface(
02817         const QString& busName,
02818         const QString& objectPath,
02819         QObject* parent = 0
02820     );
02821 
02830     ChannelInterfacePasswordInterface(
02831         const QDBusConnection& connection,
02832         const QString& busName,
02833         const QString& objectPath,
02834         QObject* parent = 0
02835     );
02836 
02843     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
02844 
02852     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
02853 
02861     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02862 
02863 public Q_SLOTS:
02876     inline QDBusPendingReply<uint> GetPasswordFlags()
02877     {
02878         if (!invalidationReason().isEmpty()) {
02879             return QDBusPendingReply<uint>(QDBusMessage::createError(
02880                 invalidationReason(),
02881                 invalidationMessage()
02882             ));
02883         }
02884 
02885 
02886         return asyncCall(QLatin1String("GetPasswordFlags"));
02887     }
02888 
02904     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
02905     {
02906         if (!invalidationReason().isEmpty()) {
02907             return QDBusPendingReply<bool>(QDBusMessage::createError(
02908                 invalidationReason(),
02909                 invalidationMessage()
02910             ));
02911         }
02912 
02913 
02914         QList<QVariant> argumentList;
02915         argumentList << QVariant::fromValue(password);
02916         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
02917     }
02918 
02919 Q_SIGNALS:
02934     void PasswordFlagsChanged(uint added, uint removed);
02935 
02936 protected:
02937     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02938 };
02939 
02947 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
02948 {
02949     Q_OBJECT
02950 
02951 public:
02958     static inline const char *staticInterfaceName()
02959     {
02960         return "org.freedesktop.Telepathy.Channel.Interface.ServicePoint";
02961     }
02962 
02970     ChannelInterfaceServicePointInterface(
02971         const QString& busName,
02972         const QString& objectPath,
02973         QObject* parent = 0
02974     );
02975 
02984     ChannelInterfaceServicePointInterface(
02985         const QDBusConnection& connection,
02986         const QString& busName,
02987         const QString& objectPath,
02988         QObject* parent = 0
02989     );
02990 
02997     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
02998 
03006     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
03007 
03015     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03016 
03030     Q_PROPERTY(Tp::ServicePoint InitialServicePoint READ InitialServicePoint)
03031 
03032     
03040     inline Tp::ServicePoint InitialServicePoint() const TELEPATHY_GNUC_DEPRECATED
03041     {
03042         return qvariant_cast<Tp::ServicePoint>(internalPropGet("InitialServicePoint"));
03043     }
03044 
03053     Q_PROPERTY(Tp::ServicePoint CurrentServicePoint READ CurrentServicePoint)
03054 
03055     
03063     inline Tp::ServicePoint CurrentServicePoint() const TELEPATHY_GNUC_DEPRECATED
03064     {
03065         return qvariant_cast<Tp::ServicePoint>(internalPropGet("CurrentServicePoint"));
03066     }
03067 
03068 Q_SIGNALS:
03085     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
03086 
03087 protected:
03088     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03089 };
03090 
03098 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
03099 {
03100     Q_OBJECT
03101 
03102 public:
03109     static inline const char *staticInterfaceName()
03110     {
03111         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
03112     }
03113 
03121     ChannelInterfaceTubeInterface(
03122         const QString& busName,
03123         const QString& objectPath,
03124         QObject* parent = 0
03125     );
03126 
03135     ChannelInterfaceTubeInterface(
03136         const QDBusConnection& connection,
03137         const QString& busName,
03138         const QString& objectPath,
03139         QObject* parent = 0
03140     );
03141 
03148     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
03149 
03157     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
03158 
03166     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03167 
03207     Q_PROPERTY(QVariantMap Parameters READ Parameters)
03208 
03209     
03217     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
03218     {
03219         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
03220     }
03221 
03231     Q_PROPERTY(uint State READ State)
03232 
03233     
03241     inline uint State() const TELEPATHY_GNUC_DEPRECATED
03242     {
03243         return qvariant_cast<uint>(internalPropGet("State"));
03244     }
03245 
03246 Q_SIGNALS:
03257     void TubeChannelStateChanged(uint state);
03258 
03259 protected:
03260     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03261 };
03262 
03270 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
03271 {
03272     Q_OBJECT
03273 
03274 public:
03281     static inline const char *staticInterfaceName()
03282     {
03283         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
03284     }
03285 
03293     ChannelTypeContactListInterface(
03294         const QString& busName,
03295         const QString& objectPath,
03296         QObject* parent = 0
03297     );
03298 
03307     ChannelTypeContactListInterface(
03308         const QDBusConnection& connection,
03309         const QString& busName,
03310         const QString& objectPath,
03311         QObject* parent = 0
03312     );
03313 
03320     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
03321 
03329     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
03330 
03338     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03339 
03340 protected:
03341     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03342 };
03343 
03351 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
03352 {
03353     Q_OBJECT
03354 
03355 public:
03362     static inline const char *staticInterfaceName()
03363     {
03364         return "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
03365     }
03366 
03374     ChannelTypeContactSearchInterface(
03375         const QString& busName,
03376         const QString& objectPath,
03377         QObject* parent = 0
03378     );
03379 
03388     ChannelTypeContactSearchInterface(
03389         const QDBusConnection& connection,
03390         const QString& busName,
03391         const QString& objectPath,
03392         QObject* parent = 0
03393     );
03394 
03401     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
03402 
03410     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
03411 
03419     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03420 
03427     Q_PROPERTY(uint SearchState READ SearchState)
03428 
03429     
03437     inline uint SearchState() const TELEPATHY_GNUC_DEPRECATED
03438     {
03439         return qvariant_cast<uint>(internalPropGet("SearchState"));
03440     }
03441 
03463     Q_PROPERTY(uint Limit READ Limit)
03464 
03465     
03473     inline uint Limit() const TELEPATHY_GNUC_DEPRECATED
03474     {
03475         return qvariant_cast<uint>(internalPropGet("Limit"));
03476     }
03477 
03489     Q_PROPERTY(QStringList AvailableSearchKeys READ AvailableSearchKeys)
03490 
03491     
03499     inline QStringList AvailableSearchKeys() const TELEPATHY_GNUC_DEPRECATED
03500     {
03501         return qvariant_cast<QStringList>(internalPropGet("AvailableSearchKeys"));
03502     }
03503 
03521     Q_PROPERTY(QString Server READ Server)
03522 
03523     
03531     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
03532     {
03533         return qvariant_cast<QString>(internalPropGet("Server"));
03534     }
03535 
03536 public Q_SLOTS:
03549     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms)
03550     {
03551         if (!invalidationReason().isEmpty()) {
03552             return QDBusPendingReply<>(QDBusMessage::createError(
03553                 invalidationReason(),
03554                 invalidationMessage()
03555             ));
03556         }
03557 
03558 
03559         QList<QVariant> argumentList;
03560         argumentList << QVariant::fromValue(terms);
03561         return asyncCallWithArgumentList(QLatin1String("Search"), argumentList);
03562     }
03563 
03571     inline QDBusPendingReply<> More()
03572     {
03573         if (!invalidationReason().isEmpty()) {
03574             return QDBusPendingReply<>(QDBusMessage::createError(
03575                 invalidationReason(),
03576                 invalidationMessage()
03577             ));
03578         }
03579 
03580 
03581         return asyncCall(QLatin1String("More"));
03582     }
03583 
03609     inline QDBusPendingReply<> Stop()
03610     {
03611         if (!invalidationReason().isEmpty()) {
03612             return QDBusPendingReply<>(QDBusMessage::createError(
03613                 invalidationReason(),
03614                 invalidationMessage()
03615             ));
03616         }
03617 
03618 
03619         return asyncCall(QLatin1String("Stop"));
03620     }
03621 
03622 Q_SIGNALS:
03666     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
03667 
03680     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
03681 
03682 protected:
03683     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03684 };
03685 
03693 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
03694 {
03695     Q_OBJECT
03696 
03697 public:
03704     static inline const char *staticInterfaceName()
03705     {
03706         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
03707     }
03708 
03716     ChannelTypeFileTransferInterface(
03717         const QString& busName,
03718         const QString& objectPath,
03719         QObject* parent = 0
03720     );
03721 
03730     ChannelTypeFileTransferInterface(
03731         const QDBusConnection& connection,
03732         const QString& busName,
03733         const QString& objectPath,
03734         QObject* parent = 0
03735     );
03736 
03743     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
03744 
03752     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
03753 
03761     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03762 
03769     Q_PROPERTY(uint State READ State)
03770 
03771     
03779     inline uint State() const TELEPATHY_GNUC_DEPRECATED
03780     {
03781         return qvariant_cast<uint>(internalPropGet("State"));
03782     }
03783 
03795     Q_PROPERTY(QString ContentType READ ContentType)
03796 
03797     
03805     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
03806     {
03807         return qvariant_cast<QString>(internalPropGet("ContentType"));
03808     }
03809 
03825     Q_PROPERTY(QString Filename READ Filename)
03826 
03827     
03835     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
03836     {
03837         return qvariant_cast<QString>(internalPropGet("Filename"));
03838     }
03839 
03857     Q_PROPERTY(qulonglong Size READ Size)
03858 
03859     
03867     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
03868     {
03869         return qvariant_cast<qulonglong>(internalPropGet("Size"));
03870     }
03871 
03892     Q_PROPERTY(uint ContentHashType READ ContentHashType)
03893 
03894     
03902     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
03903     {
03904         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
03905     }
03906 
03921     Q_PROPERTY(QString ContentHash READ ContentHash)
03922 
03923     
03931     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
03932     {
03933         return qvariant_cast<QString>(internalPropGet("ContentHash"));
03934     }
03935 
03947     Q_PROPERTY(QString Description READ Description)
03948 
03949     
03957     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
03958     {
03959         return qvariant_cast<QString>(internalPropGet("Description"));
03960     }
03961 
03972     Q_PROPERTY(qlonglong Date READ Date)
03973 
03974     
03982     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
03983     {
03984         return qvariant_cast<qlonglong>(internalPropGet("Date"));
03985     }
03986 
04009     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
04010 
04011     
04019     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
04020     {
04021         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
04022     }
04023 
04031     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
04032 
04033     
04041     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
04042     {
04043         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
04044     }
04045 
04062     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
04063 
04064     
04072     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
04073     {
04074         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
04075     }
04076 
04077 public Q_SLOTS:
04117     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
04118     {
04119         if (!invalidationReason().isEmpty()) {
04120             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04121                 invalidationReason(),
04122                 invalidationMessage()
04123             ));
04124         }
04125 
04126 
04127         QList<QVariant> argumentList;
04128         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
04129         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
04130     }
04131 
04160     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
04161     {
04162         if (!invalidationReason().isEmpty()) {
04163             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04164                 invalidationReason(),
04165                 invalidationMessage()
04166             ));
04167         }
04168 
04169 
04170         QList<QVariant> argumentList;
04171         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04172         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
04173     }
04174 
04175 Q_SIGNALS:
04193     void FileTransferStateChanged(uint state, uint reason);
04194 
04207     void TransferredBytesChanged(qulonglong count);
04208 
04220     void InitialOffsetDefined(qulonglong initialOffset);
04221 
04222 protected:
04223     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04224 };
04225 
04233 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
04234 {
04235     Q_OBJECT
04236 
04237 public:
04244     static inline const char *staticInterfaceName()
04245     {
04246         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
04247     }
04248 
04256     ChannelTypeRoomListInterface(
04257         const QString& busName,
04258         const QString& objectPath,
04259         QObject* parent = 0
04260     );
04261 
04270     ChannelTypeRoomListInterface(
04271         const QDBusConnection& connection,
04272         const QString& busName,
04273         const QString& objectPath,
04274         QObject* parent = 0
04275     );
04276 
04283     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
04284 
04292     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
04293 
04301     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04302 
04312     Q_PROPERTY(QString Server READ Server)
04313 
04314     
04322     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
04323     {
04324         return qvariant_cast<QString>(internalPropGet("Server"));
04325     }
04326 
04327 public Q_SLOTS:
04338     inline QDBusPendingReply<bool> GetListingRooms()
04339     {
04340         if (!invalidationReason().isEmpty()) {
04341             return QDBusPendingReply<bool>(QDBusMessage::createError(
04342                 invalidationReason(),
04343                 invalidationMessage()
04344             ));
04345         }
04346 
04347 
04348         return asyncCall(QLatin1String("GetListingRooms"));
04349     }
04350 
04359     inline QDBusPendingReply<> ListRooms()
04360     {
04361         if (!invalidationReason().isEmpty()) {
04362             return QDBusPendingReply<>(QDBusMessage::createError(
04363                 invalidationReason(),
04364                 invalidationMessage()
04365             ));
04366         }
04367 
04368 
04369         return asyncCall(QLatin1String("ListRooms"));
04370     }
04371 
04379     inline QDBusPendingReply<> StopListing()
04380     {
04381         if (!invalidationReason().isEmpty()) {
04382             return QDBusPendingReply<>(QDBusMessage::createError(
04383                 invalidationReason(),
04384                 invalidationMessage()
04385             ));
04386         }
04387 
04388 
04389         return asyncCall(QLatin1String("StopListing"));
04390     }
04391 
04392 Q_SIGNALS:
04446     void GotRooms(const Tp::RoomInfoList& rooms);
04447 
04458     void ListingRooms(bool listing);
04459 
04460 protected:
04461     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04462 };
04463 
04471 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
04472 {
04473     Q_OBJECT
04474 
04475 public:
04482     static inline const char *staticInterfaceName()
04483     {
04484         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
04485     }
04486 
04494     ChannelTypeStreamTubeInterface(
04495         const QString& busName,
04496         const QString& objectPath,
04497         QObject* parent = 0
04498     );
04499 
04508     ChannelTypeStreamTubeInterface(
04509         const QDBusConnection& connection,
04510         const QString& busName,
04511         const QString& objectPath,
04512         QObject* parent = 0
04513     );
04514 
04521     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
04522 
04530     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
04531 
04539     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04540 
04557     Q_PROPERTY(QString Service READ Service)
04558 
04559     
04567     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
04568     {
04569         return qvariant_cast<QString>(internalPropGet("Service"));
04570     }
04571 
04600     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
04601 
04602     
04610     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
04611     {
04612         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
04613     }
04614 
04615 public Q_SLOTS:
04641     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
04642     {
04643         if (!invalidationReason().isEmpty()) {
04644             return QDBusPendingReply<>(QDBusMessage::createError(
04645                 invalidationReason(),
04646                 invalidationMessage()
04647             ));
04648         }
04649 
04650 
04651         QList<QVariant> argumentList;
04652         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
04653         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
04654     }
04655 
04689     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
04690     {
04691         if (!invalidationReason().isEmpty()) {
04692             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04693                 invalidationReason(),
04694                 invalidationMessage()
04695             ));
04696         }
04697 
04698 
04699         QList<QVariant> argumentList;
04700         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
04701         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
04702     }
04703 
04704 Q_SIGNALS:
04741     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
04742 
04756     void NewLocalConnection(uint connectionID);
04757 
04785     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
04786 
04787 protected:
04788     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04789 };
04790 
04798 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
04799 {
04800     Q_OBJECT
04801 
04802 public:
04809     static inline const char *staticInterfaceName()
04810     {
04811         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
04812     }
04813 
04821     ChannelTypeStreamedMediaInterface(
04822         const QString& busName,
04823         const QString& objectPath,
04824         QObject* parent = 0
04825     );
04826 
04835     ChannelTypeStreamedMediaInterface(
04836         const QDBusConnection& connection,
04837         const QString& busName,
04838         const QString& objectPath,
04839         QObject* parent = 0
04840     );
04841 
04848     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
04849 
04857     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
04858 
04866     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04867 
04950     Q_PROPERTY(bool InitialAudio READ InitialAudio)
04951 
04952     
04960     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
04961     {
04962         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
04963     }
04964 
04979     Q_PROPERTY(bool InitialVideo READ InitialVideo)
04980 
04981     
04989     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
04990     {
04991         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
04992     }
04993 
05030     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
05031 
05032     
05040     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
05041     {
05042         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
05043     }
05044 
05045 public Q_SLOTS:
05066     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
05067     {
05068         if (!invalidationReason().isEmpty()) {
05069             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
05070                 invalidationReason(),
05071                 invalidationMessage()
05072             ));
05073         }
05074 
05075 
05076         return asyncCall(QLatin1String("ListStreams"));
05077     }
05078 
05098     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
05099     {
05100         if (!invalidationReason().isEmpty()) {
05101             return QDBusPendingReply<>(QDBusMessage::createError(
05102                 invalidationReason(),
05103                 invalidationMessage()
05104             ));
05105         }
05106 
05107 
05108         QList<QVariant> argumentList;
05109         argumentList << QVariant::fromValue(streams);
05110         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
05111     }
05112 
05142     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
05143     {
05144         if (!invalidationReason().isEmpty()) {
05145             return QDBusPendingReply<>(QDBusMessage::createError(
05146                 invalidationReason(),
05147                 invalidationMessage()
05148             ));
05149         }
05150 
05151 
05152         QList<QVariant> argumentList;
05153         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
05154         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
05155     }
05156 
05200     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
05201     {
05202         if (!invalidationReason().isEmpty()) {
05203             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
05204                 invalidationReason(),
05205                 invalidationMessage()
05206             ));
05207         }
05208 
05209 
05210         QList<QVariant> argumentList;
05211         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
05212         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
05213     }
05214 
05215 Q_SIGNALS:
05280     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
05281 
05311     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
05312 
05330     void StreamError(uint streamID, uint errorCode, const QString& message);
05331 
05341     void StreamRemoved(uint streamID);
05342 
05356     void StreamStateChanged(uint streamID, uint streamState);
05357 
05358 protected:
05359     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05360 };
05361 
05369 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
05370 {
05371     Q_OBJECT
05372 
05373 public:
05380     static inline const char *staticInterfaceName()
05381     {
05382         return "org.freedesktop.Telepathy.Channel.Type.Text";
05383     }
05384 
05392     ChannelTypeTextInterface(
05393         const QString& busName,
05394         const QString& objectPath,
05395         QObject* parent = 0
05396     );
05397 
05406     ChannelTypeTextInterface(
05407         const QDBusConnection& connection,
05408         const QString& busName,
05409         const QString& objectPath,
05410         QObject* parent = 0
05411     );
05412 
05419     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
05420 
05428     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
05429 
05437     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05438 
05439 public Q_SLOTS:
05450     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
05451     {
05452         if (!invalidationReason().isEmpty()) {
05453             return QDBusPendingReply<>(QDBusMessage::createError(
05454                 invalidationReason(),
05455                 invalidationMessage()
05456             ));
05457         }
05458 
05459 
05460         QList<QVariant> argumentList;
05461         argumentList << QVariant::fromValue(IDs);
05462         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
05463     }
05464 
05475     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
05476     {
05477         if (!invalidationReason().isEmpty()) {
05478             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
05479                 invalidationReason(),
05480                 invalidationMessage()
05481             ));
05482         }
05483 
05484 
05485         return asyncCall(QLatin1String("GetMessageTypes"));
05486     }
05487 
05511     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
05512     {
05513         if (!invalidationReason().isEmpty()) {
05514             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
05515                 invalidationReason(),
05516                 invalidationMessage()
05517             ));
05518         }
05519 
05520 
05521         QList<QVariant> argumentList;
05522         argumentList << QVariant::fromValue(clear);
05523         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
05524     }
05525 
05551     inline QDBusPendingReply<> Send(uint type, const QString& text)
05552     {
05553         if (!invalidationReason().isEmpty()) {
05554             return QDBusPendingReply<>(QDBusMessage::createError(
05555                 invalidationReason(),
05556                 invalidationMessage()
05557             ));
05558         }
05559 
05560 
05561         QList<QVariant> argumentList;
05562         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
05563         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
05564     }
05565 
05566 Q_SIGNALS:
05574     void LostMessage();
05575 
05609     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
05610 
05637     void SendError(uint error, uint timestamp, uint type, const QString& text);
05638 
05660     void Sent(uint timestamp, uint type, const QString& text);
05661 
05662 protected:
05663     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05664 };
05665 
05673 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
05674 {
05675     Q_OBJECT
05676 
05677 public:
05684     static inline const char *staticInterfaceName()
05685     {
05686         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
05687     }
05688 
05696     ChannelTypeTubesInterface(
05697         const QString& busName,
05698         const QString& objectPath,
05699         QObject* parent = 0
05700     );
05701 
05710     ChannelTypeTubesInterface(
05711         const QDBusConnection& connection,
05712         const QString& busName,
05713         const QString& objectPath,
05714         QObject* parent = 0
05715     );
05716 
05723     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
05724 
05732     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
05733 
05741     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05742 
05743 public Q_SLOTS:
05773     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
05774     {
05775         if (!invalidationReason().isEmpty()) {
05776             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
05777                 invalidationReason(),
05778                 invalidationMessage()
05779             ));
05780         }
05781 
05782 
05783         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
05784     }
05785 
05794     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
05795     {
05796         if (!invalidationReason().isEmpty()) {
05797             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
05798                 invalidationReason(),
05799                 invalidationMessage()
05800             ));
05801         }
05802 
05803 
05804         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
05805     }
05806 
05817     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
05818     {
05819         if (!invalidationReason().isEmpty()) {
05820             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
05821                 invalidationReason(),
05822                 invalidationMessage()
05823             ));
05824         }
05825 
05826 
05827         return asyncCall(QLatin1String("ListTubes"));
05828     }
05829 
05852     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
05853     {
05854         if (!invalidationReason().isEmpty()) {
05855             return QDBusPendingReply<uint>(QDBusMessage::createError(
05856                 invalidationReason(),
05857                 invalidationMessage()
05858             ));
05859         }
05860 
05861 
05862         QList<QVariant> argumentList;
05863         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
05864         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
05865     }
05866 
05917     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
05918     {
05919         if (!invalidationReason().isEmpty()) {
05920             return QDBusPendingReply<uint>(QDBusMessage::createError(
05921                 invalidationReason(),
05922                 invalidationMessage()
05923             ));
05924         }
05925 
05926 
05927         QList<QVariant> argumentList;
05928         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05929         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
05930     }
05931 
05949     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
05950     {
05951         if (!invalidationReason().isEmpty()) {
05952             return QDBusPendingReply<QString>(QDBusMessage::createError(
05953                 invalidationReason(),
05954                 invalidationMessage()
05955             ));
05956         }
05957 
05958 
05959         QList<QVariant> argumentList;
05960         argumentList << QVariant::fromValue(ID);
05961         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
05962     }
05963 
05996     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
05997     {
05998         if (!invalidationReason().isEmpty()) {
05999             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06000                 invalidationReason(),
06001                 invalidationMessage()
06002             ));
06003         }
06004 
06005 
06006         QList<QVariant> argumentList;
06007         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06008         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
06009     }
06010 
06020     inline QDBusPendingReply<> CloseTube(uint ID)
06021     {
06022         if (!invalidationReason().isEmpty()) {
06023             return QDBusPendingReply<>(QDBusMessage::createError(
06024                 invalidationReason(),
06025                 invalidationMessage()
06026             ));
06027         }
06028 
06029 
06030         QList<QVariant> argumentList;
06031         argumentList << QVariant::fromValue(ID);
06032         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
06033     }
06034 
06049     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
06050     {
06051         if (!invalidationReason().isEmpty()) {
06052             return QDBusPendingReply<QString>(QDBusMessage::createError(
06053                 invalidationReason(),
06054                 invalidationMessage()
06055             ));
06056         }
06057 
06058 
06059         QList<QVariant> argumentList;
06060         argumentList << QVariant::fromValue(ID);
06061         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
06062     }
06063 
06079     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
06080     {
06081         if (!invalidationReason().isEmpty()) {
06082             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
06083                 invalidationReason(),
06084                 invalidationMessage()
06085             ));
06086         }
06087 
06088 
06089         QList<QVariant> argumentList;
06090         argumentList << QVariant::fromValue(ID);
06091         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
06092     }
06093 
06114     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
06115     {
06116         if (!invalidationReason().isEmpty()) {
06117             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
06118                 invalidationReason(),
06119                 invalidationMessage()
06120             ));
06121         }
06122 
06123 
06124         QList<QVariant> argumentList;
06125         argumentList << QVariant::fromValue(ID);
06126         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
06127     }
06128 
06129 Q_SIGNALS:
06159     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
06160 
06174     void TubeStateChanged(uint ID, uint state);
06175 
06186     void TubeClosed(uint ID);
06187 
06206     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
06207 
06222     void StreamTubeNewConnection(uint ID, uint handle);
06223 
06224 protected:
06225     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06226 };
06227 }
06228 }
06229 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
06230 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
06231 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
06232 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
06233 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
06234 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
06235 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
06236 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
06237 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
06238 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
06239 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
06240 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
06241 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
06242 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
06243 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
06244 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
06245 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
06246 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
06247 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
06248 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


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