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 
00217     Q_PROPERTY(uint TargetHandle READ TargetHandle)
00218 
00219     
00227     inline uint TargetHandle() const TELEPATHY_GNUC_DEPRECATED
00228     {
00229         return qvariant_cast<uint>(internalPropGet("TargetHandle"));
00230     }
00231 
00279     Q_PROPERTY(QString TargetID READ TargetID)
00280 
00281     
00289     inline QString TargetID() const TELEPATHY_GNUC_DEPRECATED
00290     {
00291         return qvariant_cast<QString>(internalPropGet("TargetID"));
00292     }
00293 
00307     Q_PROPERTY(uint TargetHandleType READ TargetHandleType)
00308 
00309     
00317     inline uint TargetHandleType() const TELEPATHY_GNUC_DEPRECATED
00318     {
00319         return qvariant_cast<uint>(internalPropGet("TargetHandleType"));
00320     }
00321 
00384     Q_PROPERTY(bool Requested READ Requested)
00385 
00386     
00394     inline bool Requested() const TELEPATHY_GNUC_DEPRECATED
00395     {
00396         return qvariant_cast<bool>(internalPropGet("Requested"));
00397     }
00398 
00454     Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)
00455 
00456     
00464     inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
00465     {
00466         return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
00467     }
00468 
00497     Q_PROPERTY(QString InitiatorID READ InitiatorID)
00498 
00499     
00507     inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
00508     {
00509         return qvariant_cast<QString>(internalPropGet("InitiatorID"));
00510     }
00511 
00512 public Q_SLOTS:
00522     inline QDBusPendingReply<> Close()
00523     {
00524         if (!invalidationReason().isEmpty()) {
00525             return QDBusPendingReply<>(QDBusMessage::createError(
00526                 invalidationReason(),
00527                 invalidationMessage()
00528             ));
00529         }
00530 
00531 
00532         return asyncCall(QLatin1String("Close"));
00533     }
00534 
00547     inline QDBusPendingReply<QString> GetChannelType()
00548     {
00549         if (!invalidationReason().isEmpty()) {
00550             return QDBusPendingReply<QString>(QDBusMessage::createError(
00551                 invalidationReason(),
00552                 invalidationMessage()
00553             ));
00554         }
00555 
00556 
00557         return asyncCall(QLatin1String("GetChannelType"));
00558     }
00559 
00578     inline QDBusPendingReply<uint, uint> GetHandle()
00579     {
00580         if (!invalidationReason().isEmpty()) {
00581             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00582                 invalidationReason(),
00583                 invalidationMessage()
00584             ));
00585         }
00586 
00587 
00588         return asyncCall(QLatin1String("GetHandle"));
00589     }
00590 
00603     inline QDBusPendingReply<QStringList> GetInterfaces()
00604     {
00605         if (!invalidationReason().isEmpty()) {
00606             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00607                 invalidationReason(),
00608                 invalidationMessage()
00609             ));
00610         }
00611 
00612 
00613         return asyncCall(QLatin1String("GetInterfaces"));
00614     }
00615 
00616 Q_SIGNALS:
00624     void Closed();
00625 
00626 protected:
00627     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00628 };
00629 
00637 class TELEPATHY_QT4_EXPORT ChannelInterfaceAnonymityInterface : public Tp::AbstractInterface
00638 {
00639     Q_OBJECT
00640 
00641 public:
00648     static inline const char *staticInterfaceName()
00649     {
00650         return "org.freedesktop.Telepathy.Channel.Interface.Anonymity";
00651     }
00652 
00660     ChannelInterfaceAnonymityInterface(
00661         const QString& busName,
00662         const QString& objectPath,
00663         QObject* parent = 0
00664     );
00665 
00674     ChannelInterfaceAnonymityInterface(
00675         const QDBusConnection& connection,
00676         const QString& busName,
00677         const QString& objectPath,
00678         QObject* parent = 0
00679     );
00680 
00687     ChannelInterfaceAnonymityInterface(Tp::DBusProxy *proxy);
00688 
00696     explicit ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface);
00697 
00705     ChannelInterfaceAnonymityInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00706 
00713     Q_PROPERTY(uint AnonymityModes READ AnonymityModes)
00714 
00715     
00723     inline uint AnonymityModes() const TELEPATHY_GNUC_DEPRECATED
00724     {
00725         return qvariant_cast<uint>(internalPropGet("AnonymityModes"));
00726     }
00727 
00734     Q_PROPERTY(bool AnonymityMandatory READ AnonymityMandatory)
00735 
00736     
00744     inline bool AnonymityMandatory() const TELEPATHY_GNUC_DEPRECATED
00745     {
00746         return qvariant_cast<bool>(internalPropGet("AnonymityMandatory"));
00747     }
00748 
00764     Q_PROPERTY(QString AnonymousID READ AnonymousID)
00765 
00766     
00774     inline QString AnonymousID() const TELEPATHY_GNUC_DEPRECATED
00775     {
00776         return qvariant_cast<QString>(internalPropGet("AnonymousID"));
00777     }
00778 
00779 protected:
00780     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00781 };
00782 
00790 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00791 {
00792     Q_OBJECT
00793 
00794 public:
00801     static inline const char *staticInterfaceName()
00802     {
00803         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
00804     }
00805 
00813     ChannelInterfaceCallStateInterface(
00814         const QString& busName,
00815         const QString& objectPath,
00816         QObject* parent = 0
00817     );
00818 
00827     ChannelInterfaceCallStateInterface(
00828         const QDBusConnection& connection,
00829         const QString& busName,
00830         const QString& objectPath,
00831         QObject* parent = 0
00832     );
00833 
00840     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00841 
00849     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00850 
00858     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00859 
00860 public Q_SLOTS:
00871     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
00872     {
00873         if (!invalidationReason().isEmpty()) {
00874             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00875                 invalidationReason(),
00876                 invalidationMessage()
00877             ));
00878         }
00879 
00880 
00881         return asyncCall(QLatin1String("GetCallStates"));
00882     }
00883 
00884 Q_SIGNALS:
00898     void CallStateChanged(uint contact, uint state);
00899 
00900 protected:
00901     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00902 };
00903 
00911 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00912 {
00913     Q_OBJECT
00914 
00915 public:
00922     static inline const char *staticInterfaceName()
00923     {
00924         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
00925     }
00926 
00934     ChannelInterfaceChatStateInterface(
00935         const QString& busName,
00936         const QString& objectPath,
00937         QObject* parent = 0
00938     );
00939 
00948     ChannelInterfaceChatStateInterface(
00949         const QDBusConnection& connection,
00950         const QString& busName,
00951         const QString& objectPath,
00952         QObject* parent = 0
00953     );
00954 
00961     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00962 
00970     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00971 
00979     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00980 
01010     Q_PROPERTY(Tp::ChatStateMap ChatStates READ ChatStates)
01011 
01012     
01020     inline Tp::ChatStateMap ChatStates() const TELEPATHY_GNUC_DEPRECATED
01021     {
01022         return qvariant_cast<Tp::ChatStateMap>(internalPropGet("ChatStates"));
01023     }
01024 
01025 public Q_SLOTS:
01036     inline QDBusPendingReply<> SetChatState(uint state)
01037     {
01038         if (!invalidationReason().isEmpty()) {
01039             return QDBusPendingReply<>(QDBusMessage::createError(
01040                 invalidationReason(),
01041                 invalidationMessage()
01042             ));
01043         }
01044 
01045 
01046         QList<QVariant> argumentList;
01047         argumentList << QVariant::fromValue(state);
01048         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
01049     }
01050 
01051 Q_SIGNALS:
01066     void ChatStateChanged(uint contact, uint state);
01067 
01068 protected:
01069     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01070 };
01071 
01079 class TELEPATHY_QT4_EXPORT ChannelInterfaceConferenceInterface : public Tp::AbstractInterface
01080 {
01081     Q_OBJECT
01082 
01083 public:
01090     static inline const char *staticInterfaceName()
01091     {
01092         return "org.freedesktop.Telepathy.Channel.Interface.Conference";
01093     }
01094 
01102     ChannelInterfaceConferenceInterface(
01103         const QString& busName,
01104         const QString& objectPath,
01105         QObject* parent = 0
01106     );
01107 
01116     ChannelInterfaceConferenceInterface(
01117         const QDBusConnection& connection,
01118         const QString& busName,
01119         const QString& objectPath,
01120         QObject* parent = 0
01121     );
01122 
01129     ChannelInterfaceConferenceInterface(Tp::DBusProxy *proxy);
01130 
01138     explicit ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface);
01139 
01147     ChannelInterfaceConferenceInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01148 
01171     Q_PROPERTY(Tp::ObjectPathList Channels READ Channels)
01172 
01173     
01181     inline Tp::ObjectPathList Channels() const TELEPATHY_GNUC_DEPRECATED
01182     {
01183         return qvariant_cast<Tp::ObjectPathList>(internalPropGet("Channels"));
01184     }
01185 
01243     Q_PROPERTY(Tp::ObjectPathList InitialChannels READ InitialChannels)
01244 
01245     
01253     inline Tp::ObjectPathList InitialChannels() const TELEPATHY_GNUC_DEPRECATED
01254     {
01255         return qvariant_cast<Tp::ObjectPathList>(internalPropGet("InitialChannels"));
01256     }
01257 
01327     Q_PROPERTY(Tp::UIntList InitialInviteeHandles READ InitialInviteeHandles)
01328 
01329     
01337     inline Tp::UIntList InitialInviteeHandles() const TELEPATHY_GNUC_DEPRECATED
01338     {
01339         return qvariant_cast<Tp::UIntList>(internalPropGet("InitialInviteeHandles"));
01340     }
01341 
01362     Q_PROPERTY(QStringList InitialInviteeIDs READ InitialInviteeIDs)
01363 
01364     
01372     inline QStringList InitialInviteeIDs() const TELEPATHY_GNUC_DEPRECATED
01373     {
01374         return qvariant_cast<QStringList>(internalPropGet("InitialInviteeIDs"));
01375     }
01376 
01400     Q_PROPERTY(QString InvitationMessage READ InvitationMessage)
01401 
01402     
01410     inline QString InvitationMessage() const TELEPATHY_GNUC_DEPRECATED
01411     {
01412         return qvariant_cast<QString>(internalPropGet("InvitationMessage"));
01413     }
01414 
01474     Q_PROPERTY(Tp::ChannelOriginatorMap OriginalChannels READ OriginalChannels)
01475 
01476     
01484     inline Tp::ChannelOriginatorMap OriginalChannels() const TELEPATHY_GNUC_DEPRECATED
01485     {
01486         return qvariant_cast<Tp::ChannelOriginatorMap>(internalPropGet("OriginalChannels"));
01487     }
01488 
01489 Q_SIGNALS:
01511     void ChannelMerged(const QDBusObjectPath& channel, uint channelSpecificHandle, const QVariantMap& properties);
01512 
01533     void ChannelRemoved(const QDBusObjectPath& channel, const QVariantMap& details);
01534 
01535 protected:
01536     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01537 };
01538 
01546 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
01547 {
01548     Q_OBJECT
01549 
01550 public:
01557     static inline const char *staticInterfaceName()
01558     {
01559         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
01560     }
01561 
01569     ChannelInterfaceDTMFInterface(
01570         const QString& busName,
01571         const QString& objectPath,
01572         QObject* parent = 0
01573     );
01574 
01583     ChannelInterfaceDTMFInterface(
01584         const QDBusConnection& connection,
01585         const QString& busName,
01586         const QString& objectPath,
01587         QObject* parent = 0
01588     );
01589 
01596     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
01597 
01605     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
01606 
01614     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01615 
01623     Q_PROPERTY(bool CurrentlySendingTones READ CurrentlySendingTones)
01624 
01625     
01633     inline bool CurrentlySendingTones() const TELEPATHY_GNUC_DEPRECATED
01634     {
01635         return qvariant_cast<bool>(internalPropGet("CurrentlySendingTones"));
01636     }
01637 
01646     Q_PROPERTY(QString InitialTones READ InitialTones)
01647 
01648     
01656     inline QString InitialTones() const TELEPATHY_GNUC_DEPRECATED
01657     {
01658         return qvariant_cast<QString>(internalPropGet("InitialTones"));
01659     }
01660 
01661 public Q_SLOTS:
01687     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
01688     {
01689         if (!invalidationReason().isEmpty()) {
01690             return QDBusPendingReply<>(QDBusMessage::createError(
01691                 invalidationReason(),
01692                 invalidationMessage()
01693             ));
01694         }
01695 
01696 
01697         QList<QVariant> argumentList;
01698         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01699         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
01700     }
01701 
01719     inline QDBusPendingReply<> StopTone(uint streamID)
01720     {
01721         if (!invalidationReason().isEmpty()) {
01722             return QDBusPendingReply<>(QDBusMessage::createError(
01723                 invalidationReason(),
01724                 invalidationMessage()
01725             ));
01726         }
01727 
01728 
01729         QList<QVariant> argumentList;
01730         argumentList << QVariant::fromValue(streamID);
01731         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
01732     }
01733 
01752     inline QDBusPendingReply<> MultipleTones(const QString& tones)
01753     {
01754         if (!invalidationReason().isEmpty()) {
01755             return QDBusPendingReply<>(QDBusMessage::createError(
01756                 invalidationReason(),
01757                 invalidationMessage()
01758             ));
01759         }
01760 
01761 
01762         QList<QVariant> argumentList;
01763         argumentList << QVariant::fromValue(tones);
01764         return asyncCallWithArgumentList(QLatin1String("MultipleTones"), argumentList);
01765     }
01766 
01767 Q_SIGNALS:
01782     void SendingTones(const QString& tones);
01783 
01793     void StoppedTones(bool cancelled);
01794 
01795 protected:
01796     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01797 };
01798 
01806 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01807 {
01808     Q_OBJECT
01809 
01810 public:
01817     static inline const char *staticInterfaceName()
01818     {
01819         return "org.freedesktop.Telepathy.Channel.Interface.Group";
01820     }
01821 
01829     ChannelInterfaceGroupInterface(
01830         const QString& busName,
01831         const QString& objectPath,
01832         QObject* parent = 0
01833     );
01834 
01843     ChannelInterfaceGroupInterface(
01844         const QDBusConnection& connection,
01845         const QString& busName,
01846         const QString& objectPath,
01847         QObject* parent = 0
01848     );
01849 
01856     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01857 
01865     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01866 
01874     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01875 
01884     Q_PROPERTY(uint GroupFlags READ GroupFlags)
01885 
01886     
01894     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
01895     {
01896         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
01897     }
01898 
01910     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
01911 
01912     
01920     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01921     {
01922         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
01923     }
01924 
01931     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01932 
01933     
01941     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01942     {
01943         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01944     }
01945 
01951     Q_PROPERTY(Tp::UIntList Members READ Members)
01952 
01953     
01961     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01962     {
01963         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
01964     }
01965 
01972     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
01973 
01974     
01982     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01983     {
01984         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
01985     }
01986 
01997     Q_PROPERTY(uint SelfHandle READ SelfHandle)
01998 
01999     
02007     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
02008     {
02009         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
02010     }
02011 
02012 public Q_SLOTS:
02036     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
02037     {
02038         if (!invalidationReason().isEmpty()) {
02039             return QDBusPendingReply<>(QDBusMessage::createError(
02040                 invalidationReason(),
02041                 invalidationMessage()
02042             ));
02043         }
02044 
02045 
02046         QList<QVariant> argumentList;
02047         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02048         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
02049     }
02050 
02068     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
02069     {
02070         if (!invalidationReason().isEmpty()) {
02071             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
02072                 invalidationReason(),
02073                 invalidationMessage()
02074             ));
02075         }
02076 
02077 
02078         return asyncCall(QLatin1String("GetAllMembers"));
02079     }
02080 
02090     inline QDBusPendingReply<uint> GetGroupFlags()
02091     {
02092         if (!invalidationReason().isEmpty()) {
02093             return QDBusPendingReply<uint>(QDBusMessage::createError(
02094                 invalidationReason(),
02095                 invalidationMessage()
02096             ));
02097         }
02098 
02099 
02100         return asyncCall(QLatin1String("GetGroupFlags"));
02101     }
02102 
02123     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
02124     {
02125         if (!invalidationReason().isEmpty()) {
02126             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02127                 invalidationReason(),
02128                 invalidationMessage()
02129             ));
02130         }
02131 
02132 
02133         QList<QVariant> argumentList;
02134         argumentList << QVariant::fromValue(handles);
02135         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
02136     }
02137 
02144     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
02145     {
02146         if (!invalidationReason().isEmpty()) {
02147             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02148                 invalidationReason(),
02149                 invalidationMessage()
02150             ));
02151         }
02152 
02153 
02154         return asyncCall(QLatin1String("GetLocalPendingMembers"));
02155     }
02156 
02170     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
02171     {
02172         if (!invalidationReason().isEmpty()) {
02173             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
02174                 invalidationReason(),
02175                 invalidationMessage()
02176             ));
02177         }
02178 
02179 
02180         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
02181     }
02182 
02188     inline QDBusPendingReply<Tp::UIntList> GetMembers()
02189     {
02190         if (!invalidationReason().isEmpty()) {
02191             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02192                 invalidationReason(),
02193                 invalidationMessage()
02194             ));
02195         }
02196 
02197 
02198         return asyncCall(QLatin1String("GetMembers"));
02199     }
02200 
02207     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
02208     {
02209         if (!invalidationReason().isEmpty()) {
02210             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
02211                 invalidationReason(),
02212                 invalidationMessage()
02213             ));
02214         }
02215 
02216 
02217         return asyncCall(QLatin1String("GetRemotePendingMembers"));
02218     }
02219 
02225     inline QDBusPendingReply<uint> GetSelfHandle()
02226     {
02227         if (!invalidationReason().isEmpty()) {
02228             return QDBusPendingReply<uint>(QDBusMessage::createError(
02229                 invalidationReason(),
02230                 invalidationMessage()
02231             ));
02232         }
02233 
02234 
02235         return asyncCall(QLatin1String("GetSelfHandle"));
02236     }
02237 
02286     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
02287     {
02288         if (!invalidationReason().isEmpty()) {
02289             return QDBusPendingReply<>(QDBusMessage::createError(
02290                 invalidationReason(),
02291                 invalidationMessage()
02292             ));
02293         }
02294 
02295 
02296         QList<QVariant> argumentList;
02297         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
02298         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
02299     }
02300 
02320     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
02321     {
02322         if (!invalidationReason().isEmpty()) {
02323             return QDBusPendingReply<>(QDBusMessage::createError(
02324                 invalidationReason(),
02325                 invalidationMessage()
02326             ));
02327         }
02328 
02329 
02330         QList<QVariant> argumentList;
02331         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
02332         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
02333     }
02334 
02335 Q_SIGNALS:
02354     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
02355 
02365     void SelfHandleChanged(uint selfHandle);
02366 
02381     void GroupFlagsChanged(uint added, uint removed);
02382 
02434     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);
02435 
02540     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
02541 
02542 protected:
02543     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02544 };
02545 
02553 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
02554 {
02555     Q_OBJECT
02556 
02557 public:
02564     static inline const char *staticInterfaceName()
02565     {
02566         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
02567     }
02568 
02576     ChannelInterfaceHoldInterface(
02577         const QString& busName,
02578         const QString& objectPath,
02579         QObject* parent = 0
02580     );
02581 
02590     ChannelInterfaceHoldInterface(
02591         const QDBusConnection& connection,
02592         const QString& busName,
02593         const QString& objectPath,
02594         QObject* parent = 0
02595     );
02596 
02603     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
02604 
02612     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
02613 
02621     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02622 
02623 public Q_SLOTS:
02637     inline QDBusPendingReply<uint, uint> GetHoldState()
02638     {
02639         if (!invalidationReason().isEmpty()) {
02640             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02641                 invalidationReason(),
02642                 invalidationMessage()
02643             ));
02644         }
02645 
02646 
02647         return asyncCall(QLatin1String("GetHoldState"));
02648     }
02649 
02706     inline QDBusPendingReply<> RequestHold(bool hold)
02707     {
02708         if (!invalidationReason().isEmpty()) {
02709             return QDBusPendingReply<>(QDBusMessage::createError(
02710                 invalidationReason(),
02711                 invalidationMessage()
02712             ));
02713         }
02714 
02715 
02716         QList<QVariant> argumentList;
02717         argumentList << QVariant::fromValue(hold);
02718         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
02719     }
02720 
02721 Q_SIGNALS:
02738     void HoldStateChanged(uint holdState, uint reason);
02739 
02740 protected:
02741     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02742 };
02743 
02751 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
02752 {
02753     Q_OBJECT
02754 
02755 public:
02762     static inline const char *staticInterfaceName()
02763     {
02764         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
02765     }
02766 
02774     ChannelInterfaceMediaSignallingInterface(
02775         const QString& busName,
02776         const QString& objectPath,
02777         QObject* parent = 0
02778     );
02779 
02788     ChannelInterfaceMediaSignallingInterface(
02789         const QDBusConnection& connection,
02790         const QString& busName,
02791         const QString& objectPath,
02792         QObject* parent = 0
02793     );
02794 
02801     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02802 
02810     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02811 
02819     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02820 
02821 public Q_SLOTS:
02828     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
02829     {
02830         if (!invalidationReason().isEmpty()) {
02831             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02832                 invalidationReason(),
02833                 invalidationMessage()
02834             ));
02835         }
02836 
02837 
02838         return asyncCall(QLatin1String("GetSessionHandlers"));
02839     }
02840 
02841 Q_SIGNALS:
02857     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02858 
02859 protected:
02860     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02861 };
02862 
02870 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02871 {
02872     Q_OBJECT
02873 
02874 public:
02881     static inline const char *staticInterfaceName()
02882     {
02883         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02884     }
02885 
02893     ChannelInterfaceMessagesInterface(
02894         const QString& busName,
02895         const QString& objectPath,
02896         QObject* parent = 0
02897     );
02898 
02907     ChannelInterfaceMessagesInterface(
02908         const QDBusConnection& connection,
02909         const QString& busName,
02910         const QString& objectPath,
02911         QObject* parent = 0
02912     );
02913 
02920     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02921 
02929     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
02930 
02938     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02939 
02985     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02986 
02987     
02995     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02996     {
02997         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02998     }
02999 
03005     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
03006 
03007     
03015     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
03016     {
03017         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
03018     }
03019 
03029     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
03030 
03031     
03039     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
03040     {
03041         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
03042     }
03043 
03049     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
03050 
03051     
03059     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
03060     {
03061         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
03062     }
03063 
03064 public Q_SLOTS:
03106     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
03107     {
03108         if (!invalidationReason().isEmpty()) {
03109             return QDBusPendingReply<QString>(QDBusMessage::createError(
03110                 invalidationReason(),
03111                 invalidationMessage()
03112             ));
03113         }
03114 
03115 
03116         QList<QVariant> argumentList;
03117         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
03118         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
03119     }
03120 
03154     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
03155     {
03156         if (!invalidationReason().isEmpty()) {
03157             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
03158                 invalidationReason(),
03159                 invalidationMessage()
03160             ));
03161         }
03162 
03163 
03164         QList<QVariant> argumentList;
03165         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
03166         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
03167     }
03168 
03169 Q_SIGNALS:
03217     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
03218 
03232     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
03233 
03252     void MessageReceived(const Tp::MessagePartList& message);
03253 
03254 protected:
03255     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03256 };
03257 
03265 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
03266 {
03267     Q_OBJECT
03268 
03269 public:
03276     static inline const char *staticInterfaceName()
03277     {
03278         return "org.freedesktop.Telepathy.Channel.Interface.Password";
03279     }
03280 
03288     ChannelInterfacePasswordInterface(
03289         const QString& busName,
03290         const QString& objectPath,
03291         QObject* parent = 0
03292     );
03293 
03302     ChannelInterfacePasswordInterface(
03303         const QDBusConnection& connection,
03304         const QString& busName,
03305         const QString& objectPath,
03306         QObject* parent = 0
03307     );
03308 
03315     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
03316 
03324     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
03325 
03333     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03334 
03335 public Q_SLOTS:
03348     inline QDBusPendingReply<uint> GetPasswordFlags()
03349     {
03350         if (!invalidationReason().isEmpty()) {
03351             return QDBusPendingReply<uint>(QDBusMessage::createError(
03352                 invalidationReason(),
03353                 invalidationMessage()
03354             ));
03355         }
03356 
03357 
03358         return asyncCall(QLatin1String("GetPasswordFlags"));
03359     }
03360 
03376     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
03377     {
03378         if (!invalidationReason().isEmpty()) {
03379             return QDBusPendingReply<bool>(QDBusMessage::createError(
03380                 invalidationReason(),
03381                 invalidationMessage()
03382             ));
03383         }
03384 
03385 
03386         QList<QVariant> argumentList;
03387         argumentList << QVariant::fromValue(password);
03388         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
03389     }
03390 
03391 Q_SIGNALS:
03406     void PasswordFlagsChanged(uint added, uint removed);
03407 
03408 protected:
03409     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03410 };
03411 
03419 class TELEPATHY_QT4_EXPORT ChannelInterfaceServicePointInterface : public Tp::AbstractInterface
03420 {
03421     Q_OBJECT
03422 
03423 public:
03430     static inline const char *staticInterfaceName()
03431     {
03432         return "org.freedesktop.Telepathy.Channel.Interface.ServicePoint";
03433     }
03434 
03442     ChannelInterfaceServicePointInterface(
03443         const QString& busName,
03444         const QString& objectPath,
03445         QObject* parent = 0
03446     );
03447 
03456     ChannelInterfaceServicePointInterface(
03457         const QDBusConnection& connection,
03458         const QString& busName,
03459         const QString& objectPath,
03460         QObject* parent = 0
03461     );
03462 
03469     ChannelInterfaceServicePointInterface(Tp::DBusProxy *proxy);
03470 
03478     explicit ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface);
03479 
03487     ChannelInterfaceServicePointInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03488 
03502     Q_PROPERTY(Tp::ServicePoint InitialServicePoint READ InitialServicePoint)
03503 
03504     
03512     inline Tp::ServicePoint InitialServicePoint() const TELEPATHY_GNUC_DEPRECATED
03513     {
03514         return qvariant_cast<Tp::ServicePoint>(internalPropGet("InitialServicePoint"));
03515     }
03516 
03525     Q_PROPERTY(Tp::ServicePoint CurrentServicePoint READ CurrentServicePoint)
03526 
03527     
03535     inline Tp::ServicePoint CurrentServicePoint() const TELEPATHY_GNUC_DEPRECATED
03536     {
03537         return qvariant_cast<Tp::ServicePoint>(internalPropGet("CurrentServicePoint"));
03538     }
03539 
03540 Q_SIGNALS:
03557     void ServicePointChanged(const Tp::ServicePoint& servicePoint);
03558 
03559 protected:
03560     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03561 };
03562 
03570 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
03571 {
03572     Q_OBJECT
03573 
03574 public:
03581     static inline const char *staticInterfaceName()
03582     {
03583         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
03584     }
03585 
03593     ChannelInterfaceTubeInterface(
03594         const QString& busName,
03595         const QString& objectPath,
03596         QObject* parent = 0
03597     );
03598 
03607     ChannelInterfaceTubeInterface(
03608         const QDBusConnection& connection,
03609         const QString& busName,
03610         const QString& objectPath,
03611         QObject* parent = 0
03612     );
03613 
03620     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
03621 
03629     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
03630 
03638     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03639 
03679     Q_PROPERTY(QVariantMap Parameters READ Parameters)
03680 
03681     
03689     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
03690     {
03691         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
03692     }
03693 
03703     Q_PROPERTY(uint State READ State)
03704 
03705     
03713     inline uint State() const TELEPATHY_GNUC_DEPRECATED
03714     {
03715         return qvariant_cast<uint>(internalPropGet("State"));
03716     }
03717 
03718 Q_SIGNALS:
03729     void TubeChannelStateChanged(uint state);
03730 
03731 protected:
03732     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03733 };
03734 
03742 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
03743 {
03744     Q_OBJECT
03745 
03746 public:
03753     static inline const char *staticInterfaceName()
03754     {
03755         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
03756     }
03757 
03765     ChannelTypeContactListInterface(
03766         const QString& busName,
03767         const QString& objectPath,
03768         QObject* parent = 0
03769     );
03770 
03779     ChannelTypeContactListInterface(
03780         const QDBusConnection& connection,
03781         const QString& busName,
03782         const QString& objectPath,
03783         QObject* parent = 0
03784     );
03785 
03792     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
03793 
03801     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
03802 
03810     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03811 
03812 protected:
03813     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03814 };
03815 
03823 class TELEPATHY_QT4_EXPORT ChannelTypeContactSearchInterface : public Tp::AbstractInterface
03824 {
03825     Q_OBJECT
03826 
03827 public:
03834     static inline const char *staticInterfaceName()
03835     {
03836         return "org.freedesktop.Telepathy.Channel.Type.ContactSearch";
03837     }
03838 
03846     ChannelTypeContactSearchInterface(
03847         const QString& busName,
03848         const QString& objectPath,
03849         QObject* parent = 0
03850     );
03851 
03860     ChannelTypeContactSearchInterface(
03861         const QDBusConnection& connection,
03862         const QString& busName,
03863         const QString& objectPath,
03864         QObject* parent = 0
03865     );
03866 
03873     ChannelTypeContactSearchInterface(Tp::DBusProxy *proxy);
03874 
03882     explicit ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface);
03883 
03891     ChannelTypeContactSearchInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03892 
03899     Q_PROPERTY(uint SearchState READ SearchState)
03900 
03901     
03909     inline uint SearchState() const TELEPATHY_GNUC_DEPRECATED
03910     {
03911         return qvariant_cast<uint>(internalPropGet("SearchState"));
03912     }
03913 
03935     Q_PROPERTY(uint Limit READ Limit)
03936 
03937     
03945     inline uint Limit() const TELEPATHY_GNUC_DEPRECATED
03946     {
03947         return qvariant_cast<uint>(internalPropGet("Limit"));
03948     }
03949 
03961     Q_PROPERTY(QStringList AvailableSearchKeys READ AvailableSearchKeys)
03962 
03963     
03971     inline QStringList AvailableSearchKeys() const TELEPATHY_GNUC_DEPRECATED
03972     {
03973         return qvariant_cast<QStringList>(internalPropGet("AvailableSearchKeys"));
03974     }
03975 
03993     Q_PROPERTY(QString Server READ Server)
03994 
03995     
04003     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
04004     {
04005         return qvariant_cast<QString>(internalPropGet("Server"));
04006     }
04007 
04008 public Q_SLOTS:
04021     inline QDBusPendingReply<> Search(const Tp::ContactSearchMap& terms)
04022     {
04023         if (!invalidationReason().isEmpty()) {
04024             return QDBusPendingReply<>(QDBusMessage::createError(
04025                 invalidationReason(),
04026                 invalidationMessage()
04027             ));
04028         }
04029 
04030 
04031         QList<QVariant> argumentList;
04032         argumentList << QVariant::fromValue(terms);
04033         return asyncCallWithArgumentList(QLatin1String("Search"), argumentList);
04034     }
04035 
04043     inline QDBusPendingReply<> More()
04044     {
04045         if (!invalidationReason().isEmpty()) {
04046             return QDBusPendingReply<>(QDBusMessage::createError(
04047                 invalidationReason(),
04048                 invalidationMessage()
04049             ));
04050         }
04051 
04052 
04053         return asyncCall(QLatin1String("More"));
04054     }
04055 
04081     inline QDBusPendingReply<> Stop()
04082     {
04083         if (!invalidationReason().isEmpty()) {
04084             return QDBusPendingReply<>(QDBusMessage::createError(
04085                 invalidationReason(),
04086                 invalidationMessage()
04087             ));
04088         }
04089 
04090 
04091         return asyncCall(QLatin1String("Stop"));
04092     }
04093 
04094 Q_SIGNALS:
04138     void SearchStateChanged(uint state, const QString& error, const QVariantMap& details);
04139 
04152     void SearchResultReceived(const Tp::ContactSearchResultMap& result);
04153 
04154 protected:
04155     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04156 };
04157 
04165 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
04166 {
04167     Q_OBJECT
04168 
04169 public:
04176     static inline const char *staticInterfaceName()
04177     {
04178         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
04179     }
04180 
04188     ChannelTypeFileTransferInterface(
04189         const QString& busName,
04190         const QString& objectPath,
04191         QObject* parent = 0
04192     );
04193 
04202     ChannelTypeFileTransferInterface(
04203         const QDBusConnection& connection,
04204         const QString& busName,
04205         const QString& objectPath,
04206         QObject* parent = 0
04207     );
04208 
04215     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
04216 
04224     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
04225 
04233     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04234 
04241     Q_PROPERTY(uint State READ State)
04242 
04243     
04251     inline uint State() const TELEPATHY_GNUC_DEPRECATED
04252     {
04253         return qvariant_cast<uint>(internalPropGet("State"));
04254     }
04255 
04267     Q_PROPERTY(QString ContentType READ ContentType)
04268 
04269     
04277     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
04278     {
04279         return qvariant_cast<QString>(internalPropGet("ContentType"));
04280     }
04281 
04297     Q_PROPERTY(QString Filename READ Filename)
04298 
04299     
04307     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
04308     {
04309         return qvariant_cast<QString>(internalPropGet("Filename"));
04310     }
04311 
04329     Q_PROPERTY(qulonglong Size READ Size)
04330 
04331     
04339     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
04340     {
04341         return qvariant_cast<qulonglong>(internalPropGet("Size"));
04342     }
04343 
04364     Q_PROPERTY(uint ContentHashType READ ContentHashType)
04365 
04366     
04374     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
04375     {
04376         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
04377     }
04378 
04393     Q_PROPERTY(QString ContentHash READ ContentHash)
04394 
04395     
04403     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
04404     {
04405         return qvariant_cast<QString>(internalPropGet("ContentHash"));
04406     }
04407 
04419     Q_PROPERTY(QString Description READ Description)
04420 
04421     
04429     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
04430     {
04431         return qvariant_cast<QString>(internalPropGet("Description"));
04432     }
04433 
04444     Q_PROPERTY(qlonglong Date READ Date)
04445 
04446     
04454     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
04455     {
04456         return qvariant_cast<qlonglong>(internalPropGet("Date"));
04457     }
04458 
04481     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
04482 
04483     
04491     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
04492     {
04493         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
04494     }
04495 
04503     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
04504 
04505     
04513     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
04514     {
04515         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
04516     }
04517 
04534     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
04535 
04536     
04544     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
04545     {
04546         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
04547     }
04548 
04549 public Q_SLOTS:
04589     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
04590     {
04591         if (!invalidationReason().isEmpty()) {
04592             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04593                 invalidationReason(),
04594                 invalidationMessage()
04595             ));
04596         }
04597 
04598 
04599         QList<QVariant> argumentList;
04600         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
04601         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
04602     }
04603 
04632     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
04633     {
04634         if (!invalidationReason().isEmpty()) {
04635             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04636                 invalidationReason(),
04637                 invalidationMessage()
04638             ));
04639         }
04640 
04641 
04642         QList<QVariant> argumentList;
04643         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
04644         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
04645     }
04646 
04647 Q_SIGNALS:
04665     void FileTransferStateChanged(uint state, uint reason);
04666 
04679     void TransferredBytesChanged(qulonglong count);
04680 
04692     void InitialOffsetDefined(qulonglong initialOffset);
04693 
04694 protected:
04695     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04696 };
04697 
04705 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
04706 {
04707     Q_OBJECT
04708 
04709 public:
04716     static inline const char *staticInterfaceName()
04717     {
04718         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
04719     }
04720 
04728     ChannelTypeRoomListInterface(
04729         const QString& busName,
04730         const QString& objectPath,
04731         QObject* parent = 0
04732     );
04733 
04742     ChannelTypeRoomListInterface(
04743         const QDBusConnection& connection,
04744         const QString& busName,
04745         const QString& objectPath,
04746         QObject* parent = 0
04747     );
04748 
04755     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
04756 
04764     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
04765 
04773     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04774 
04784     Q_PROPERTY(QString Server READ Server)
04785 
04786     
04794     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
04795     {
04796         return qvariant_cast<QString>(internalPropGet("Server"));
04797     }
04798 
04799 public Q_SLOTS:
04810     inline QDBusPendingReply<bool> GetListingRooms()
04811     {
04812         if (!invalidationReason().isEmpty()) {
04813             return QDBusPendingReply<bool>(QDBusMessage::createError(
04814                 invalidationReason(),
04815                 invalidationMessage()
04816             ));
04817         }
04818 
04819 
04820         return asyncCall(QLatin1String("GetListingRooms"));
04821     }
04822 
04831     inline QDBusPendingReply<> ListRooms()
04832     {
04833         if (!invalidationReason().isEmpty()) {
04834             return QDBusPendingReply<>(QDBusMessage::createError(
04835                 invalidationReason(),
04836                 invalidationMessage()
04837             ));
04838         }
04839 
04840 
04841         return asyncCall(QLatin1String("ListRooms"));
04842     }
04843 
04851     inline QDBusPendingReply<> StopListing()
04852     {
04853         if (!invalidationReason().isEmpty()) {
04854             return QDBusPendingReply<>(QDBusMessage::createError(
04855                 invalidationReason(),
04856                 invalidationMessage()
04857             ));
04858         }
04859 
04860 
04861         return asyncCall(QLatin1String("StopListing"));
04862     }
04863 
04864 Q_SIGNALS:
04918     void GotRooms(const Tp::RoomInfoList& rooms);
04919 
04930     void ListingRooms(bool listing);
04931 
04932 protected:
04933     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04934 };
04935 
04943 class TELEPATHY_QT4_EXPORT ChannelTypeServerTLSConnectionInterface : public Tp::AbstractInterface
04944 {
04945     Q_OBJECT
04946 
04947 public:
04954     static inline const char *staticInterfaceName()
04955     {
04956         return "org.freedesktop.Telepathy.Channel.Type.ServerTLSConnection";
04957     }
04958 
04966     ChannelTypeServerTLSConnectionInterface(
04967         const QString& busName,
04968         const QString& objectPath,
04969         QObject* parent = 0
04970     );
04971 
04980     ChannelTypeServerTLSConnectionInterface(
04981         const QDBusConnection& connection,
04982         const QString& busName,
04983         const QString& objectPath,
04984         QObject* parent = 0
04985     );
04986 
04993     ChannelTypeServerTLSConnectionInterface(Tp::DBusProxy *proxy);
04994 
05002     explicit ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface);
05003 
05011     ChannelTypeServerTLSConnectionInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05012 
05019     Q_PROPERTY(QDBusObjectPath ServerCertificate READ ServerCertificate)
05020 
05021     
05029     inline QDBusObjectPath ServerCertificate() const TELEPATHY_GNUC_DEPRECATED
05030     {
05031         return qvariant_cast<QDBusObjectPath>(internalPropGet("ServerCertificate"));
05032     }
05033 
05041     Q_PROPERTY(QString Hostname READ Hostname)
05042 
05043     
05051     inline QString Hostname() const TELEPATHY_GNUC_DEPRECATED
05052     {
05053         return qvariant_cast<QString>(internalPropGet("Hostname"));
05054     }
05055 
05056 protected:
05057     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05058 };
05059 
05067 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
05068 {
05069     Q_OBJECT
05070 
05071 public:
05078     static inline const char *staticInterfaceName()
05079     {
05080         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
05081     }
05082 
05090     ChannelTypeStreamTubeInterface(
05091         const QString& busName,
05092         const QString& objectPath,
05093         QObject* parent = 0
05094     );
05095 
05104     ChannelTypeStreamTubeInterface(
05105         const QDBusConnection& connection,
05106         const QString& busName,
05107         const QString& objectPath,
05108         QObject* parent = 0
05109     );
05110 
05117     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
05118 
05126     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
05127 
05135     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05136 
05153     Q_PROPERTY(QString Service READ Service)
05154 
05155     
05163     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
05164     {
05165         return qvariant_cast<QString>(internalPropGet("Service"));
05166     }
05167 
05196     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
05197 
05198     
05206     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
05207     {
05208         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
05209     }
05210 
05211 public Q_SLOTS:
05237     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
05238     {
05239         if (!invalidationReason().isEmpty()) {
05240             return QDBusPendingReply<>(QDBusMessage::createError(
05241                 invalidationReason(),
05242                 invalidationMessage()
05243             ));
05244         }
05245 
05246 
05247         QList<QVariant> argumentList;
05248         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
05249         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
05250     }
05251 
05285     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
05286     {
05287         if (!invalidationReason().isEmpty()) {
05288             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05289                 invalidationReason(),
05290                 invalidationMessage()
05291             ));
05292         }
05293 
05294 
05295         QList<QVariant> argumentList;
05296         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
05297         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
05298     }
05299 
05300 Q_SIGNALS:
05337     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
05338 
05352     void NewLocalConnection(uint connectionID);
05353 
05381     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
05382 
05383 protected:
05384     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05385 };
05386 
05394 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
05395 {
05396     Q_OBJECT
05397 
05398 public:
05405     static inline const char *staticInterfaceName()
05406     {
05407         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
05408     }
05409 
05417     ChannelTypeStreamedMediaInterface(
05418         const QString& busName,
05419         const QString& objectPath,
05420         QObject* parent = 0
05421     );
05422 
05431     ChannelTypeStreamedMediaInterface(
05432         const QDBusConnection& connection,
05433         const QString& busName,
05434         const QString& objectPath,
05435         QObject* parent = 0
05436     );
05437 
05444     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
05445 
05453     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
05454 
05462     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05463 
05546     Q_PROPERTY(bool InitialAudio READ InitialAudio)
05547 
05548     
05556     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
05557     {
05558         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
05559     }
05560 
05575     Q_PROPERTY(bool InitialVideo READ InitialVideo)
05576 
05577     
05585     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
05586     {
05587         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
05588     }
05589 
05626     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
05627 
05628     
05636     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
05637     {
05638         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
05639     }
05640 
05641 public Q_SLOTS:
05662     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
05663     {
05664         if (!invalidationReason().isEmpty()) {
05665             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
05666                 invalidationReason(),
05667                 invalidationMessage()
05668             ));
05669         }
05670 
05671 
05672         return asyncCall(QLatin1String("ListStreams"));
05673     }
05674 
05694     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
05695     {
05696         if (!invalidationReason().isEmpty()) {
05697             return QDBusPendingReply<>(QDBusMessage::createError(
05698                 invalidationReason(),
05699                 invalidationMessage()
05700             ));
05701         }
05702 
05703 
05704         QList<QVariant> argumentList;
05705         argumentList << QVariant::fromValue(streams);
05706         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
05707     }
05708 
05738     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
05739     {
05740         if (!invalidationReason().isEmpty()) {
05741             return QDBusPendingReply<>(QDBusMessage::createError(
05742                 invalidationReason(),
05743                 invalidationMessage()
05744             ));
05745         }
05746 
05747 
05748         QList<QVariant> argumentList;
05749         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
05750         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
05751     }
05752 
05796     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
05797     {
05798         if (!invalidationReason().isEmpty()) {
05799             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
05800                 invalidationReason(),
05801                 invalidationMessage()
05802             ));
05803         }
05804 
05805 
05806         QList<QVariant> argumentList;
05807         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
05808         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
05809     }
05810 
05811 Q_SIGNALS:
05876     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
05877 
05907     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
05908 
05926     void StreamError(uint streamID, uint errorCode, const QString& message);
05927 
05937     void StreamRemoved(uint streamID);
05938 
05952     void StreamStateChanged(uint streamID, uint streamState);
05953 
05954 protected:
05955     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05956 };
05957 
05965 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
05966 {
05967     Q_OBJECT
05968 
05969 public:
05976     static inline const char *staticInterfaceName()
05977     {
05978         return "org.freedesktop.Telepathy.Channel.Type.Text";
05979     }
05980 
05988     ChannelTypeTextInterface(
05989         const QString& busName,
05990         const QString& objectPath,
05991         QObject* parent = 0
05992     );
05993 
06002     ChannelTypeTextInterface(
06003         const QDBusConnection& connection,
06004         const QString& busName,
06005         const QString& objectPath,
06006         QObject* parent = 0
06007     );
06008 
06015     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
06016 
06024     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
06025 
06033     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06034 
06035 public Q_SLOTS:
06046     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
06047     {
06048         if (!invalidationReason().isEmpty()) {
06049             return QDBusPendingReply<>(QDBusMessage::createError(
06050                 invalidationReason(),
06051                 invalidationMessage()
06052             ));
06053         }
06054 
06055 
06056         QList<QVariant> argumentList;
06057         argumentList << QVariant::fromValue(IDs);
06058         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
06059     }
06060 
06071     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
06072     {
06073         if (!invalidationReason().isEmpty()) {
06074             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
06075                 invalidationReason(),
06076                 invalidationMessage()
06077             ));
06078         }
06079 
06080 
06081         return asyncCall(QLatin1String("GetMessageTypes"));
06082     }
06083 
06107     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
06108     {
06109         if (!invalidationReason().isEmpty()) {
06110             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
06111                 invalidationReason(),
06112                 invalidationMessage()
06113             ));
06114         }
06115 
06116 
06117         QList<QVariant> argumentList;
06118         argumentList << QVariant::fromValue(clear);
06119         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
06120     }
06121 
06147     inline QDBusPendingReply<> Send(uint type, const QString& text)
06148     {
06149         if (!invalidationReason().isEmpty()) {
06150             return QDBusPendingReply<>(QDBusMessage::createError(
06151                 invalidationReason(),
06152                 invalidationMessage()
06153             ));
06154         }
06155 
06156 
06157         QList<QVariant> argumentList;
06158         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
06159         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
06160     }
06161 
06162 Q_SIGNALS:
06170     void LostMessage();
06171 
06205     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
06206 
06233     void SendError(uint error, uint timestamp, uint type, const QString& text);
06234 
06256     void Sent(uint timestamp, uint type, const QString& text);
06257 
06258 protected:
06259     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06260 };
06261 
06269 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
06270 {
06271     Q_OBJECT
06272 
06273 public:
06280     static inline const char *staticInterfaceName()
06281     {
06282         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
06283     }
06284 
06292     ChannelTypeTubesInterface(
06293         const QString& busName,
06294         const QString& objectPath,
06295         QObject* parent = 0
06296     );
06297 
06306     ChannelTypeTubesInterface(
06307         const QDBusConnection& connection,
06308         const QString& busName,
06309         const QString& objectPath,
06310         QObject* parent = 0
06311     );
06312 
06319     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
06320 
06328     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
06329 
06337     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
06338 
06339 public Q_SLOTS:
06369     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
06370     {
06371         if (!invalidationReason().isEmpty()) {
06372             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
06373                 invalidationReason(),
06374                 invalidationMessage()
06375             ));
06376         }
06377 
06378 
06379         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
06380     }
06381 
06390     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
06391     {
06392         if (!invalidationReason().isEmpty()) {
06393             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
06394                 invalidationReason(),
06395                 invalidationMessage()
06396             ));
06397         }
06398 
06399 
06400         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
06401     }
06402 
06413     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
06414     {
06415         if (!invalidationReason().isEmpty()) {
06416             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
06417                 invalidationReason(),
06418                 invalidationMessage()
06419             ));
06420         }
06421 
06422 
06423         return asyncCall(QLatin1String("ListTubes"));
06424     }
06425 
06448     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
06449     {
06450         if (!invalidationReason().isEmpty()) {
06451             return QDBusPendingReply<uint>(QDBusMessage::createError(
06452                 invalidationReason(),
06453                 invalidationMessage()
06454             ));
06455         }
06456 
06457 
06458         QList<QVariant> argumentList;
06459         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
06460         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
06461     }
06462 
06513     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
06514     {
06515         if (!invalidationReason().isEmpty()) {
06516             return QDBusPendingReply<uint>(QDBusMessage::createError(
06517                 invalidationReason(),
06518                 invalidationMessage()
06519             ));
06520         }
06521 
06522 
06523         QList<QVariant> argumentList;
06524         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06525         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
06526     }
06527 
06545     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
06546     {
06547         if (!invalidationReason().isEmpty()) {
06548             return QDBusPendingReply<QString>(QDBusMessage::createError(
06549                 invalidationReason(),
06550                 invalidationMessage()
06551             ));
06552         }
06553 
06554 
06555         QList<QVariant> argumentList;
06556         argumentList << QVariant::fromValue(ID);
06557         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
06558     }
06559 
06592     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
06593     {
06594         if (!invalidationReason().isEmpty()) {
06595             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
06596                 invalidationReason(),
06597                 invalidationMessage()
06598             ));
06599         }
06600 
06601 
06602         QList<QVariant> argumentList;
06603         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
06604         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
06605     }
06606 
06616     inline QDBusPendingReply<> CloseTube(uint ID)
06617     {
06618         if (!invalidationReason().isEmpty()) {
06619             return QDBusPendingReply<>(QDBusMessage::createError(
06620                 invalidationReason(),
06621                 invalidationMessage()
06622             ));
06623         }
06624 
06625 
06626         QList<QVariant> argumentList;
06627         argumentList << QVariant::fromValue(ID);
06628         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
06629     }
06630 
06645     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
06646     {
06647         if (!invalidationReason().isEmpty()) {
06648             return QDBusPendingReply<QString>(QDBusMessage::createError(
06649                 invalidationReason(),
06650                 invalidationMessage()
06651             ));
06652         }
06653 
06654 
06655         QList<QVariant> argumentList;
06656         argumentList << QVariant::fromValue(ID);
06657         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
06658     }
06659 
06675     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
06676     {
06677         if (!invalidationReason().isEmpty()) {
06678             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
06679                 invalidationReason(),
06680                 invalidationMessage()
06681             ));
06682         }
06683 
06684 
06685         QList<QVariant> argumentList;
06686         argumentList << QVariant::fromValue(ID);
06687         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
06688     }
06689 
06710     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
06711     {
06712         if (!invalidationReason().isEmpty()) {
06713             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
06714                 invalidationReason(),
06715                 invalidationMessage()
06716             ));
06717         }
06718 
06719 
06720         QList<QVariant> argumentList;
06721         argumentList << QVariant::fromValue(ID);
06722         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
06723     }
06724 
06725 Q_SIGNALS:
06755     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
06756 
06770     void TubeStateChanged(uint ID, uint state);
06771 
06782     void TubeClosed(uint ID);
06783 
06802     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
06803 
06818     void StreamTubeNewConnection(uint ID, uint handle);
06819 
06820 protected:
06821     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
06822 };
06823 }
06824 }
06825 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
06826 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceAnonymityInterface*)
06827 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
06828 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
06829 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceConferenceInterface*)
06830 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
06831 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
06832 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
06833 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
06834 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
06835 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
06836 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceServicePointInterface*)
06837 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
06838 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
06839 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactSearchInterface*)
06840 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
06841 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
06842 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeServerTLSConnectionInterface*)
06843 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
06844 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
06845 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
06846 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


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