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 ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00633 {
00634     Q_OBJECT
00635 
00636 public:
00643     static inline const char *staticInterfaceName()
00644     {
00645         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
00646     }
00647 
00655     ChannelInterfaceCallStateInterface(
00656         const QString& busName,
00657         const QString& objectPath,
00658         QObject* parent = 0
00659     );
00660 
00669     ChannelInterfaceCallStateInterface(
00670         const QDBusConnection& connection,
00671         const QString& busName,
00672         const QString& objectPath,
00673         QObject* parent = 0
00674     );
00675 
00682     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00683 
00691     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00692 
00700     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00701 
00702 public Q_SLOTS:
00713     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
00714     {
00715         if (!invalidationReason().isEmpty()) {
00716             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00717                 invalidationReason(),
00718                 invalidationMessage()
00719             ));
00720         }
00721 
00722 
00723         return asyncCall(QLatin1String("GetCallStates"));
00724     }
00725 
00726 Q_SIGNALS:
00740     void CallStateChanged(uint contact, uint state);
00741 
00742 protected:
00743     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00744 };
00745 
00753 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00754 {
00755     Q_OBJECT
00756 
00757 public:
00764     static inline const char *staticInterfaceName()
00765     {
00766         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
00767     }
00768 
00776     ChannelInterfaceChatStateInterface(
00777         const QString& busName,
00778         const QString& objectPath,
00779         QObject* parent = 0
00780     );
00781 
00790     ChannelInterfaceChatStateInterface(
00791         const QDBusConnection& connection,
00792         const QString& busName,
00793         const QString& objectPath,
00794         QObject* parent = 0
00795     );
00796 
00803     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00804 
00812     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00813 
00821     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00822 
00852     Q_PROPERTY(Tp::ChatStateMap ChatStates READ ChatStates)
00853 
00854     
00862     inline Tp::ChatStateMap ChatStates() const TELEPATHY_GNUC_DEPRECATED
00863     {
00864         return qvariant_cast<Tp::ChatStateMap>(internalPropGet("ChatStates"));
00865     }
00866 
00867 public Q_SLOTS:
00878     inline QDBusPendingReply<> SetChatState(uint state)
00879     {
00880         if (!invalidationReason().isEmpty()) {
00881             return QDBusPendingReply<>(QDBusMessage::createError(
00882                 invalidationReason(),
00883                 invalidationMessage()
00884             ));
00885         }
00886 
00887 
00888         QList<QVariant> argumentList;
00889         argumentList << QVariant::fromValue(state);
00890         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
00891     }
00892 
00893 Q_SIGNALS:
00908     void ChatStateChanged(uint contact, uint state);
00909 
00910 protected:
00911     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00912 };
00913 
00921 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
00922 {
00923     Q_OBJECT
00924 
00925 public:
00932     static inline const char *staticInterfaceName()
00933     {
00934         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
00935     }
00936 
00944     ChannelInterfaceDTMFInterface(
00945         const QString& busName,
00946         const QString& objectPath,
00947         QObject* parent = 0
00948     );
00949 
00958     ChannelInterfaceDTMFInterface(
00959         const QDBusConnection& connection,
00960         const QString& busName,
00961         const QString& objectPath,
00962         QObject* parent = 0
00963     );
00964 
00971     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
00972 
00980     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
00981 
00989     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00990 
00998     Q_PROPERTY(bool CurrentlySendingTones READ CurrentlySendingTones)
00999 
01000     
01008     inline bool CurrentlySendingTones() const TELEPATHY_GNUC_DEPRECATED
01009     {
01010         return qvariant_cast<bool>(internalPropGet("CurrentlySendingTones"));
01011     }
01012 
01021     Q_PROPERTY(QString InitialTones READ InitialTones)
01022 
01023     
01031     inline QString InitialTones() const TELEPATHY_GNUC_DEPRECATED
01032     {
01033         return qvariant_cast<QString>(internalPropGet("InitialTones"));
01034     }
01035 
01036 public Q_SLOTS:
01062     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
01063     {
01064         if (!invalidationReason().isEmpty()) {
01065             return QDBusPendingReply<>(QDBusMessage::createError(
01066                 invalidationReason(),
01067                 invalidationMessage()
01068             ));
01069         }
01070 
01071 
01072         QList<QVariant> argumentList;
01073         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
01074         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
01075     }
01076 
01094     inline QDBusPendingReply<> StopTone(uint streamID)
01095     {
01096         if (!invalidationReason().isEmpty()) {
01097             return QDBusPendingReply<>(QDBusMessage::createError(
01098                 invalidationReason(),
01099                 invalidationMessage()
01100             ));
01101         }
01102 
01103 
01104         QList<QVariant> argumentList;
01105         argumentList << QVariant::fromValue(streamID);
01106         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
01107     }
01108 
01127     inline QDBusPendingReply<> MultipleTones(const QString& tones)
01128     {
01129         if (!invalidationReason().isEmpty()) {
01130             return QDBusPendingReply<>(QDBusMessage::createError(
01131                 invalidationReason(),
01132                 invalidationMessage()
01133             ));
01134         }
01135 
01136 
01137         QList<QVariant> argumentList;
01138         argumentList << QVariant::fromValue(tones);
01139         return asyncCallWithArgumentList(QLatin1String("MultipleTones"), argumentList);
01140     }
01141 
01142 Q_SIGNALS:
01157     void SendingTones(const QString& tones);
01158 
01168     void StoppedTones(bool cancelled);
01169 
01170 protected:
01171     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01172 };
01173 
01181 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
01182 {
01183     Q_OBJECT
01184 
01185 public:
01192     static inline const char *staticInterfaceName()
01193     {
01194         return "org.freedesktop.Telepathy.Channel.Interface.Group";
01195     }
01196 
01204     ChannelInterfaceGroupInterface(
01205         const QString& busName,
01206         const QString& objectPath,
01207         QObject* parent = 0
01208     );
01209 
01218     ChannelInterfaceGroupInterface(
01219         const QDBusConnection& connection,
01220         const QString& busName,
01221         const QString& objectPath,
01222         QObject* parent = 0
01223     );
01224 
01231     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01232 
01240     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01241 
01249     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01250 
01259     Q_PROPERTY(uint GroupFlags READ GroupFlags)
01260 
01261     
01269     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
01270     {
01271         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
01272     }
01273 
01285     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
01286 
01287     
01295     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01296     {
01297         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
01298     }
01299 
01306     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01307 
01308     
01316     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01317     {
01318         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01319     }
01320 
01326     Q_PROPERTY(Tp::UIntList Members READ Members)
01327 
01328     
01336     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01337     {
01338         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
01339     }
01340 
01347     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
01348 
01349     
01357     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01358     {
01359         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
01360     }
01361 
01372     Q_PROPERTY(uint SelfHandle READ SelfHandle)
01373 
01374     
01382     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
01383     {
01384         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
01385     }
01386 
01387 public Q_SLOTS:
01411     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
01412     {
01413         if (!invalidationReason().isEmpty()) {
01414             return QDBusPendingReply<>(QDBusMessage::createError(
01415                 invalidationReason(),
01416                 invalidationMessage()
01417             ));
01418         }
01419 
01420 
01421         QList<QVariant> argumentList;
01422         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01423         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
01424     }
01425 
01443     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
01444     {
01445         if (!invalidationReason().isEmpty()) {
01446             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
01447                 invalidationReason(),
01448                 invalidationMessage()
01449             ));
01450         }
01451 
01452 
01453         return asyncCall(QLatin1String("GetAllMembers"));
01454     }
01455 
01465     inline QDBusPendingReply<uint> GetGroupFlags()
01466     {
01467         if (!invalidationReason().isEmpty()) {
01468             return QDBusPendingReply<uint>(QDBusMessage::createError(
01469                 invalidationReason(),
01470                 invalidationMessage()
01471             ));
01472         }
01473 
01474 
01475         return asyncCall(QLatin1String("GetGroupFlags"));
01476     }
01477 
01498     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
01499     {
01500         if (!invalidationReason().isEmpty()) {
01501             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01502                 invalidationReason(),
01503                 invalidationMessage()
01504             ));
01505         }
01506 
01507 
01508         QList<QVariant> argumentList;
01509         argumentList << QVariant::fromValue(handles);
01510         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
01511     }
01512 
01519     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
01520     {
01521         if (!invalidationReason().isEmpty()) {
01522             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01523                 invalidationReason(),
01524                 invalidationMessage()
01525             ));
01526         }
01527 
01528 
01529         return asyncCall(QLatin1String("GetLocalPendingMembers"));
01530     }
01531 
01545     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
01546     {
01547         if (!invalidationReason().isEmpty()) {
01548             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
01549                 invalidationReason(),
01550                 invalidationMessage()
01551             ));
01552         }
01553 
01554 
01555         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
01556     }
01557 
01563     inline QDBusPendingReply<Tp::UIntList> GetMembers()
01564     {
01565         if (!invalidationReason().isEmpty()) {
01566             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01567                 invalidationReason(),
01568                 invalidationMessage()
01569             ));
01570         }
01571 
01572 
01573         return asyncCall(QLatin1String("GetMembers"));
01574     }
01575 
01582     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
01583     {
01584         if (!invalidationReason().isEmpty()) {
01585             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01586                 invalidationReason(),
01587                 invalidationMessage()
01588             ));
01589         }
01590 
01591 
01592         return asyncCall(QLatin1String("GetRemotePendingMembers"));
01593     }
01594 
01600     inline QDBusPendingReply<uint> GetSelfHandle()
01601     {
01602         if (!invalidationReason().isEmpty()) {
01603             return QDBusPendingReply<uint>(QDBusMessage::createError(
01604                 invalidationReason(),
01605                 invalidationMessage()
01606             ));
01607         }
01608 
01609 
01610         return asyncCall(QLatin1String("GetSelfHandle"));
01611     }
01612 
01661     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
01662     {
01663         if (!invalidationReason().isEmpty()) {
01664             return QDBusPendingReply<>(QDBusMessage::createError(
01665                 invalidationReason(),
01666                 invalidationMessage()
01667             ));
01668         }
01669 
01670 
01671         QList<QVariant> argumentList;
01672         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01673         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
01674     }
01675 
01695     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
01696     {
01697         if (!invalidationReason().isEmpty()) {
01698             return QDBusPendingReply<>(QDBusMessage::createError(
01699                 invalidationReason(),
01700                 invalidationMessage()
01701             ));
01702         }
01703 
01704 
01705         QList<QVariant> argumentList;
01706         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
01707         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
01708     }
01709 
01710 Q_SIGNALS:
01729     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
01730 
01740     void SelfHandleChanged(uint selfHandle);
01741 
01756     void GroupFlagsChanged(uint added, uint removed);
01757 
01805     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);
01806 
01907     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
01908 
01909 protected:
01910     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01911 };
01912 
01920 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
01921 {
01922     Q_OBJECT
01923 
01924 public:
01931     static inline const char *staticInterfaceName()
01932     {
01933         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
01934     }
01935 
01943     ChannelInterfaceHoldInterface(
01944         const QString& busName,
01945         const QString& objectPath,
01946         QObject* parent = 0
01947     );
01948 
01957     ChannelInterfaceHoldInterface(
01958         const QDBusConnection& connection,
01959         const QString& busName,
01960         const QString& objectPath,
01961         QObject* parent = 0
01962     );
01963 
01970     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
01971 
01979     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
01980 
01988     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01989 
01990 public Q_SLOTS:
02004     inline QDBusPendingReply<uint, uint> GetHoldState()
02005     {
02006         if (!invalidationReason().isEmpty()) {
02007             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
02008                 invalidationReason(),
02009                 invalidationMessage()
02010             ));
02011         }
02012 
02013 
02014         return asyncCall(QLatin1String("GetHoldState"));
02015     }
02016 
02073     inline QDBusPendingReply<> RequestHold(bool hold)
02074     {
02075         if (!invalidationReason().isEmpty()) {
02076             return QDBusPendingReply<>(QDBusMessage::createError(
02077                 invalidationReason(),
02078                 invalidationMessage()
02079             ));
02080         }
02081 
02082 
02083         QList<QVariant> argumentList;
02084         argumentList << QVariant::fromValue(hold);
02085         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
02086     }
02087 
02088 Q_SIGNALS:
02105     void HoldStateChanged(uint holdState, uint reason);
02106 
02107 protected:
02108     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02109 };
02110 
02118 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
02119 {
02120     Q_OBJECT
02121 
02122 public:
02129     static inline const char *staticInterfaceName()
02130     {
02131         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
02132     }
02133 
02141     ChannelInterfaceMediaSignallingInterface(
02142         const QString& busName,
02143         const QString& objectPath,
02144         QObject* parent = 0
02145     );
02146 
02155     ChannelInterfaceMediaSignallingInterface(
02156         const QDBusConnection& connection,
02157         const QString& busName,
02158         const QString& objectPath,
02159         QObject* parent = 0
02160     );
02161 
02168     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
02169 
02177     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
02178 
02186     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02187 
02188 public Q_SLOTS:
02195     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
02196     {
02197         if (!invalidationReason().isEmpty()) {
02198             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02199                 invalidationReason(),
02200                 invalidationMessage()
02201             ));
02202         }
02203 
02204 
02205         return asyncCall(QLatin1String("GetSessionHandlers"));
02206     }
02207 
02208 Q_SIGNALS:
02224     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02225 
02226 protected:
02227     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02228 };
02229 
02237 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02238 {
02239     Q_OBJECT
02240 
02241 public:
02248     static inline const char *staticInterfaceName()
02249     {
02250         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02251     }
02252 
02260     ChannelInterfaceMessagesInterface(
02261         const QString& busName,
02262         const QString& objectPath,
02263         QObject* parent = 0
02264     );
02265 
02274     ChannelInterfaceMessagesInterface(
02275         const QDBusConnection& connection,
02276         const QString& busName,
02277         const QString& objectPath,
02278         QObject* parent = 0
02279     );
02280 
02287     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02288 
02296     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
02297 
02305     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02306 
02352     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02353 
02354     
02362     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02363     {
02364         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02365     }
02366 
02372     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
02373 
02374     
02382     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
02383     {
02384         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
02385     }
02386 
02396     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
02397 
02398     
02406     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
02407     {
02408         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
02409     }
02410 
02416     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
02417 
02418     
02426     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
02427     {
02428         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
02429     }
02430 
02431 public Q_SLOTS:
02471     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
02472     {
02473         if (!invalidationReason().isEmpty()) {
02474             return QDBusPendingReply<QString>(QDBusMessage::createError(
02475                 invalidationReason(),
02476                 invalidationMessage()
02477             ));
02478         }
02479 
02480 
02481         QList<QVariant> argumentList;
02482         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
02483         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
02484     }
02485 
02519     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
02520     {
02521         if (!invalidationReason().isEmpty()) {
02522             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
02523                 invalidationReason(),
02524                 invalidationMessage()
02525             ));
02526         }
02527 
02528 
02529         QList<QVariant> argumentList;
02530         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
02531         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
02532     }
02533 
02534 Q_SIGNALS:
02582     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
02583 
02597     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
02598 
02612     void MessageReceived(const Tp::MessagePartList& message);
02613 
02614 protected:
02615     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02616 };
02617 
02625 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
02626 {
02627     Q_OBJECT
02628 
02629 public:
02636     static inline const char *staticInterfaceName()
02637     {
02638         return "org.freedesktop.Telepathy.Channel.Interface.Password";
02639     }
02640 
02648     ChannelInterfacePasswordInterface(
02649         const QString& busName,
02650         const QString& objectPath,
02651         QObject* parent = 0
02652     );
02653 
02662     ChannelInterfacePasswordInterface(
02663         const QDBusConnection& connection,
02664         const QString& busName,
02665         const QString& objectPath,
02666         QObject* parent = 0
02667     );
02668 
02675     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
02676 
02684     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
02685 
02693     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02694 
02695 public Q_SLOTS:
02708     inline QDBusPendingReply<uint> GetPasswordFlags()
02709     {
02710         if (!invalidationReason().isEmpty()) {
02711             return QDBusPendingReply<uint>(QDBusMessage::createError(
02712                 invalidationReason(),
02713                 invalidationMessage()
02714             ));
02715         }
02716 
02717 
02718         return asyncCall(QLatin1String("GetPasswordFlags"));
02719     }
02720 
02736     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
02737     {
02738         if (!invalidationReason().isEmpty()) {
02739             return QDBusPendingReply<bool>(QDBusMessage::createError(
02740                 invalidationReason(),
02741                 invalidationMessage()
02742             ));
02743         }
02744 
02745 
02746         QList<QVariant> argumentList;
02747         argumentList << QVariant::fromValue(password);
02748         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
02749     }
02750 
02751 Q_SIGNALS:
02766     void PasswordFlagsChanged(uint added, uint removed);
02767 
02768 protected:
02769     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02770 };
02771 
02779 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
02780 {
02781     Q_OBJECT
02782 
02783 public:
02790     static inline const char *staticInterfaceName()
02791     {
02792         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
02793     }
02794 
02802     ChannelInterfaceTubeInterface(
02803         const QString& busName,
02804         const QString& objectPath,
02805         QObject* parent = 0
02806     );
02807 
02816     ChannelInterfaceTubeInterface(
02817         const QDBusConnection& connection,
02818         const QString& busName,
02819         const QString& objectPath,
02820         QObject* parent = 0
02821     );
02822 
02829     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
02830 
02838     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
02839 
02847     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02848 
02888     Q_PROPERTY(QVariantMap Parameters READ Parameters)
02889 
02890     
02898     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
02899     {
02900         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
02901     }
02902 
02912     Q_PROPERTY(uint State READ State)
02913 
02914     
02922     inline uint State() const TELEPATHY_GNUC_DEPRECATED
02923     {
02924         return qvariant_cast<uint>(internalPropGet("State"));
02925     }
02926 
02927 Q_SIGNALS:
02938     void TubeChannelStateChanged(uint state);
02939 
02940 protected:
02941     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02942 };
02943 
02951 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
02952 {
02953     Q_OBJECT
02954 
02955 public:
02962     static inline const char *staticInterfaceName()
02963     {
02964         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
02965     }
02966 
02974     ChannelTypeContactListInterface(
02975         const QString& busName,
02976         const QString& objectPath,
02977         QObject* parent = 0
02978     );
02979 
02988     ChannelTypeContactListInterface(
02989         const QDBusConnection& connection,
02990         const QString& busName,
02991         const QString& objectPath,
02992         QObject* parent = 0
02993     );
02994 
03001     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
03002 
03010     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
03011 
03019     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03020 
03021 protected:
03022     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03023 };
03024 
03032 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
03033 {
03034     Q_OBJECT
03035 
03036 public:
03043     static inline const char *staticInterfaceName()
03044     {
03045         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
03046     }
03047 
03055     ChannelTypeFileTransferInterface(
03056         const QString& busName,
03057         const QString& objectPath,
03058         QObject* parent = 0
03059     );
03060 
03069     ChannelTypeFileTransferInterface(
03070         const QDBusConnection& connection,
03071         const QString& busName,
03072         const QString& objectPath,
03073         QObject* parent = 0
03074     );
03075 
03082     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
03083 
03091     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
03092 
03100     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03101 
03108     Q_PROPERTY(uint State READ State)
03109 
03110     
03118     inline uint State() const TELEPATHY_GNUC_DEPRECATED
03119     {
03120         return qvariant_cast<uint>(internalPropGet("State"));
03121     }
03122 
03134     Q_PROPERTY(QString ContentType READ ContentType)
03135 
03136     
03144     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
03145     {
03146         return qvariant_cast<QString>(internalPropGet("ContentType"));
03147     }
03148 
03164     Q_PROPERTY(QString Filename READ Filename)
03165 
03166     
03174     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
03175     {
03176         return qvariant_cast<QString>(internalPropGet("Filename"));
03177     }
03178 
03196     Q_PROPERTY(qulonglong Size READ Size)
03197 
03198     
03206     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
03207     {
03208         return qvariant_cast<qulonglong>(internalPropGet("Size"));
03209     }
03210 
03231     Q_PROPERTY(uint ContentHashType READ ContentHashType)
03232 
03233     
03241     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
03242     {
03243         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
03244     }
03245 
03260     Q_PROPERTY(QString ContentHash READ ContentHash)
03261 
03262     
03270     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
03271     {
03272         return qvariant_cast<QString>(internalPropGet("ContentHash"));
03273     }
03274 
03286     Q_PROPERTY(QString Description READ Description)
03287 
03288     
03296     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
03297     {
03298         return qvariant_cast<QString>(internalPropGet("Description"));
03299     }
03300 
03311     Q_PROPERTY(qlonglong Date READ Date)
03312 
03313     
03321     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
03322     {
03323         return qvariant_cast<qlonglong>(internalPropGet("Date"));
03324     }
03325 
03348     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
03349 
03350     
03358     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
03359     {
03360         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
03361     }
03362 
03370     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
03371 
03372     
03380     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
03381     {
03382         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
03383     }
03384 
03401     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
03402 
03403     
03411     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
03412     {
03413         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
03414     }
03415 
03416 public Q_SLOTS:
03456     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
03457     {
03458         if (!invalidationReason().isEmpty()) {
03459             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03460                 invalidationReason(),
03461                 invalidationMessage()
03462             ));
03463         }
03464 
03465 
03466         QList<QVariant> argumentList;
03467         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
03468         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
03469     }
03470 
03499     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
03500     {
03501         if (!invalidationReason().isEmpty()) {
03502             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03503                 invalidationReason(),
03504                 invalidationMessage()
03505             ));
03506         }
03507 
03508 
03509         QList<QVariant> argumentList;
03510         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
03511         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
03512     }
03513 
03514 Q_SIGNALS:
03532     void FileTransferStateChanged(uint state, uint reason);
03533 
03546     void TransferredBytesChanged(qulonglong count);
03547 
03559     void InitialOffsetDefined(qulonglong initialOffset);
03560 
03561 protected:
03562     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03563 };
03564 
03572 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
03573 {
03574     Q_OBJECT
03575 
03576 public:
03583     static inline const char *staticInterfaceName()
03584     {
03585         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
03586     }
03587 
03595     ChannelTypeRoomListInterface(
03596         const QString& busName,
03597         const QString& objectPath,
03598         QObject* parent = 0
03599     );
03600 
03609     ChannelTypeRoomListInterface(
03610         const QDBusConnection& connection,
03611         const QString& busName,
03612         const QString& objectPath,
03613         QObject* parent = 0
03614     );
03615 
03622     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
03623 
03631     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
03632 
03640     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03641 
03651     Q_PROPERTY(QString Server READ Server)
03652 
03653     
03661     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
03662     {
03663         return qvariant_cast<QString>(internalPropGet("Server"));
03664     }
03665 
03666 public Q_SLOTS:
03677     inline QDBusPendingReply<bool> GetListingRooms()
03678     {
03679         if (!invalidationReason().isEmpty()) {
03680             return QDBusPendingReply<bool>(QDBusMessage::createError(
03681                 invalidationReason(),
03682                 invalidationMessage()
03683             ));
03684         }
03685 
03686 
03687         return asyncCall(QLatin1String("GetListingRooms"));
03688     }
03689 
03698     inline QDBusPendingReply<> ListRooms()
03699     {
03700         if (!invalidationReason().isEmpty()) {
03701             return QDBusPendingReply<>(QDBusMessage::createError(
03702                 invalidationReason(),
03703                 invalidationMessage()
03704             ));
03705         }
03706 
03707 
03708         return asyncCall(QLatin1String("ListRooms"));
03709     }
03710 
03718     inline QDBusPendingReply<> StopListing()
03719     {
03720         if (!invalidationReason().isEmpty()) {
03721             return QDBusPendingReply<>(QDBusMessage::createError(
03722                 invalidationReason(),
03723                 invalidationMessage()
03724             ));
03725         }
03726 
03727 
03728         return asyncCall(QLatin1String("StopListing"));
03729     }
03730 
03731 Q_SIGNALS:
03776     void GotRooms(const Tp::RoomInfoList& rooms);
03777 
03788     void ListingRooms(bool listing);
03789 
03790 protected:
03791     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03792 };
03793 
03801 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
03802 {
03803     Q_OBJECT
03804 
03805 public:
03812     static inline const char *staticInterfaceName()
03813     {
03814         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
03815     }
03816 
03824     ChannelTypeStreamTubeInterface(
03825         const QString& busName,
03826         const QString& objectPath,
03827         QObject* parent = 0
03828     );
03829 
03838     ChannelTypeStreamTubeInterface(
03839         const QDBusConnection& connection,
03840         const QString& busName,
03841         const QString& objectPath,
03842         QObject* parent = 0
03843     );
03844 
03851     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
03852 
03860     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
03861 
03869     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03870 
03887     Q_PROPERTY(QString Service READ Service)
03888 
03889     
03897     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
03898     {
03899         return qvariant_cast<QString>(internalPropGet("Service"));
03900     }
03901 
03930     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
03931 
03932     
03940     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
03941     {
03942         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
03943     }
03944 
03945 public Q_SLOTS:
03971     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
03972     {
03973         if (!invalidationReason().isEmpty()) {
03974             return QDBusPendingReply<>(QDBusMessage::createError(
03975                 invalidationReason(),
03976                 invalidationMessage()
03977             ));
03978         }
03979 
03980 
03981         QList<QVariant> argumentList;
03982         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
03983         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
03984     }
03985 
04019     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
04020     {
04021         if (!invalidationReason().isEmpty()) {
04022             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
04023                 invalidationReason(),
04024                 invalidationMessage()
04025             ));
04026         }
04027 
04028 
04029         QList<QVariant> argumentList;
04030         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
04031         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
04032     }
04033 
04034 Q_SIGNALS:
04071     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
04072 
04086     void NewLocalConnection(uint connectionID);
04087 
04115     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
04116 
04117 protected:
04118     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04119 };
04120 
04128 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
04129 {
04130     Q_OBJECT
04131 
04132 public:
04139     static inline const char *staticInterfaceName()
04140     {
04141         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
04142     }
04143 
04151     ChannelTypeStreamedMediaInterface(
04152         const QString& busName,
04153         const QString& objectPath,
04154         QObject* parent = 0
04155     );
04156 
04165     ChannelTypeStreamedMediaInterface(
04166         const QDBusConnection& connection,
04167         const QString& busName,
04168         const QString& objectPath,
04169         QObject* parent = 0
04170     );
04171 
04178     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
04179 
04187     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
04188 
04196     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04197 
04280     Q_PROPERTY(bool InitialAudio READ InitialAudio)
04281 
04282     
04290     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
04291     {
04292         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
04293     }
04294 
04309     Q_PROPERTY(bool InitialVideo READ InitialVideo)
04310 
04311     
04319     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
04320     {
04321         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
04322     }
04323 
04360     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
04361 
04362     
04370     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
04371     {
04372         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
04373     }
04374 
04375 public Q_SLOTS:
04396     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
04397     {
04398         if (!invalidationReason().isEmpty()) {
04399             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
04400                 invalidationReason(),
04401                 invalidationMessage()
04402             ));
04403         }
04404 
04405 
04406         return asyncCall(QLatin1String("ListStreams"));
04407     }
04408 
04428     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
04429     {
04430         if (!invalidationReason().isEmpty()) {
04431             return QDBusPendingReply<>(QDBusMessage::createError(
04432                 invalidationReason(),
04433                 invalidationMessage()
04434             ));
04435         }
04436 
04437 
04438         QList<QVariant> argumentList;
04439         argumentList << QVariant::fromValue(streams);
04440         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
04441     }
04442 
04472     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
04473     {
04474         if (!invalidationReason().isEmpty()) {
04475             return QDBusPendingReply<>(QDBusMessage::createError(
04476                 invalidationReason(),
04477                 invalidationMessage()
04478             ));
04479         }
04480 
04481 
04482         QList<QVariant> argumentList;
04483         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
04484         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
04485     }
04486 
04530     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
04531     {
04532         if (!invalidationReason().isEmpty()) {
04533             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
04534                 invalidationReason(),
04535                 invalidationMessage()
04536             ));
04537         }
04538 
04539 
04540         QList<QVariant> argumentList;
04541         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
04542         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
04543     }
04544 
04545 Q_SIGNALS:
04610     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
04611 
04641     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
04642 
04660     void StreamError(uint streamID, uint errorCode, const QString& message);
04661 
04671     void StreamRemoved(uint streamID);
04672 
04686     void StreamStateChanged(uint streamID, uint streamState);
04687 
04688 protected:
04689     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04690 };
04691 
04699 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
04700 {
04701     Q_OBJECT
04702 
04703 public:
04710     static inline const char *staticInterfaceName()
04711     {
04712         return "org.freedesktop.Telepathy.Channel.Type.Text";
04713     }
04714 
04722     ChannelTypeTextInterface(
04723         const QString& busName,
04724         const QString& objectPath,
04725         QObject* parent = 0
04726     );
04727 
04736     ChannelTypeTextInterface(
04737         const QDBusConnection& connection,
04738         const QString& busName,
04739         const QString& objectPath,
04740         QObject* parent = 0
04741     );
04742 
04749     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
04750 
04758     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
04759 
04767     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04768 
04769 public Q_SLOTS:
04780     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
04781     {
04782         if (!invalidationReason().isEmpty()) {
04783             return QDBusPendingReply<>(QDBusMessage::createError(
04784                 invalidationReason(),
04785                 invalidationMessage()
04786             ));
04787         }
04788 
04789 
04790         QList<QVariant> argumentList;
04791         argumentList << QVariant::fromValue(IDs);
04792         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
04793     }
04794 
04805     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
04806     {
04807         if (!invalidationReason().isEmpty()) {
04808             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
04809                 invalidationReason(),
04810                 invalidationMessage()
04811             ));
04812         }
04813 
04814 
04815         return asyncCall(QLatin1String("GetMessageTypes"));
04816     }
04817 
04841     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
04842     {
04843         if (!invalidationReason().isEmpty()) {
04844             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
04845                 invalidationReason(),
04846                 invalidationMessage()
04847             ));
04848         }
04849 
04850 
04851         QList<QVariant> argumentList;
04852         argumentList << QVariant::fromValue(clear);
04853         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
04854     }
04855 
04881     inline QDBusPendingReply<> Send(uint type, const QString& text)
04882     {
04883         if (!invalidationReason().isEmpty()) {
04884             return QDBusPendingReply<>(QDBusMessage::createError(
04885                 invalidationReason(),
04886                 invalidationMessage()
04887             ));
04888         }
04889 
04890 
04891         QList<QVariant> argumentList;
04892         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
04893         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
04894     }
04895 
04896 Q_SIGNALS:
04904     void LostMessage();
04905 
04939     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
04940 
04967     void SendError(uint error, uint timestamp, uint type, const QString& text);
04968 
04990     void Sent(uint timestamp, uint type, const QString& text);
04991 
04992 protected:
04993     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04994 };
04995 
05003 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
05004 {
05005     Q_OBJECT
05006 
05007 public:
05014     static inline const char *staticInterfaceName()
05015     {
05016         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
05017     }
05018 
05026     ChannelTypeTubesInterface(
05027         const QString& busName,
05028         const QString& objectPath,
05029         QObject* parent = 0
05030     );
05031 
05040     ChannelTypeTubesInterface(
05041         const QDBusConnection& connection,
05042         const QString& busName,
05043         const QString& objectPath,
05044         QObject* parent = 0
05045     );
05046 
05053     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
05054 
05062     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
05063 
05071     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
05072 
05073 public Q_SLOTS:
05103     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
05104     {
05105         if (!invalidationReason().isEmpty()) {
05106             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
05107                 invalidationReason(),
05108                 invalidationMessage()
05109             ));
05110         }
05111 
05112 
05113         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
05114     }
05115 
05124     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
05125     {
05126         if (!invalidationReason().isEmpty()) {
05127             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
05128                 invalidationReason(),
05129                 invalidationMessage()
05130             ));
05131         }
05132 
05133 
05134         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
05135     }
05136 
05147     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
05148     {
05149         if (!invalidationReason().isEmpty()) {
05150             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
05151                 invalidationReason(),
05152                 invalidationMessage()
05153             ));
05154         }
05155 
05156 
05157         return asyncCall(QLatin1String("ListTubes"));
05158     }
05159 
05182     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
05183     {
05184         if (!invalidationReason().isEmpty()) {
05185             return QDBusPendingReply<uint>(QDBusMessage::createError(
05186                 invalidationReason(),
05187                 invalidationMessage()
05188             ));
05189         }
05190 
05191 
05192         QList<QVariant> argumentList;
05193         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
05194         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
05195     }
05196 
05247     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
05248     {
05249         if (!invalidationReason().isEmpty()) {
05250             return QDBusPendingReply<uint>(QDBusMessage::createError(
05251                 invalidationReason(),
05252                 invalidationMessage()
05253             ));
05254         }
05255 
05256 
05257         QList<QVariant> argumentList;
05258         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05259         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
05260     }
05261 
05279     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
05280     {
05281         if (!invalidationReason().isEmpty()) {
05282             return QDBusPendingReply<QString>(QDBusMessage::createError(
05283                 invalidationReason(),
05284                 invalidationMessage()
05285             ));
05286         }
05287 
05288 
05289         QList<QVariant> argumentList;
05290         argumentList << QVariant::fromValue(ID);
05291         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
05292     }
05293 
05326     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
05327     {
05328         if (!invalidationReason().isEmpty()) {
05329             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05330                 invalidationReason(),
05331                 invalidationMessage()
05332             ));
05333         }
05334 
05335 
05336         QList<QVariant> argumentList;
05337         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05338         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
05339     }
05340 
05350     inline QDBusPendingReply<> CloseTube(uint ID)
05351     {
05352         if (!invalidationReason().isEmpty()) {
05353             return QDBusPendingReply<>(QDBusMessage::createError(
05354                 invalidationReason(),
05355                 invalidationMessage()
05356             ));
05357         }
05358 
05359 
05360         QList<QVariant> argumentList;
05361         argumentList << QVariant::fromValue(ID);
05362         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
05363     }
05364 
05379     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
05380     {
05381         if (!invalidationReason().isEmpty()) {
05382             return QDBusPendingReply<QString>(QDBusMessage::createError(
05383                 invalidationReason(),
05384                 invalidationMessage()
05385             ));
05386         }
05387 
05388 
05389         QList<QVariant> argumentList;
05390         argumentList << QVariant::fromValue(ID);
05391         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
05392     }
05393 
05409     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
05410     {
05411         if (!invalidationReason().isEmpty()) {
05412             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
05413                 invalidationReason(),
05414                 invalidationMessage()
05415             ));
05416         }
05417 
05418 
05419         QList<QVariant> argumentList;
05420         argumentList << QVariant::fromValue(ID);
05421         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
05422     }
05423 
05444     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
05445     {
05446         if (!invalidationReason().isEmpty()) {
05447             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
05448                 invalidationReason(),
05449                 invalidationMessage()
05450             ));
05451         }
05452 
05453 
05454         QList<QVariant> argumentList;
05455         argumentList << QVariant::fromValue(ID);
05456         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
05457     }
05458 
05459 Q_SIGNALS:
05489     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
05490 
05504     void TubeStateChanged(uint ID, uint state);
05505 
05516     void TubeClosed(uint ID);
05517 
05536     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
05537 
05552     void StreamTubeNewConnection(uint ID, uint handle);
05553 
05554 protected:
05555     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05556 };
05557 }
05558 }
05559 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
05560 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
05561 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
05562 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
05563 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
05564 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
05565 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
05566 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
05567 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
05568 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
05569 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
05570 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
05571 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
05572 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
05573 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
05574 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
05575 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)


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