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 
00429     Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)
00430 
00431     
00439     inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
00440     {
00441         return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
00442     }
00443 
00472     Q_PROPERTY(QString InitiatorID READ InitiatorID)
00473 
00474     
00482     inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
00483     {
00484         return qvariant_cast<QString>(internalPropGet("InitiatorID"));
00485     }
00486 
00487 public Q_SLOTS:
00497     inline QDBusPendingReply<> Close()
00498     {
00499         if (!invalidationReason().isEmpty()) {
00500             return QDBusPendingReply<>(QDBusMessage::createError(
00501                 invalidationReason(),
00502                 invalidationMessage()
00503             ));
00504         }
00505 
00506 
00507         return asyncCall(QLatin1String("Close"));
00508     }
00509 
00522     inline QDBusPendingReply<QString> GetChannelType()
00523     {
00524         if (!invalidationReason().isEmpty()) {
00525             return QDBusPendingReply<QString>(QDBusMessage::createError(
00526                 invalidationReason(),
00527                 invalidationMessage()
00528             ));
00529         }
00530 
00531 
00532         return asyncCall(QLatin1String("GetChannelType"));
00533     }
00534 
00553     inline QDBusPendingReply<uint, uint> GetHandle()
00554     {
00555         if (!invalidationReason().isEmpty()) {
00556             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
00557                 invalidationReason(),
00558                 invalidationMessage()
00559             ));
00560         }
00561 
00562 
00563         return asyncCall(QLatin1String("GetHandle"));
00564     }
00565 
00578     inline QDBusPendingReply<QStringList> GetInterfaces()
00579     {
00580         if (!invalidationReason().isEmpty()) {
00581             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
00582                 invalidationReason(),
00583                 invalidationMessage()
00584             ));
00585         }
00586 
00587 
00588         return asyncCall(QLatin1String("GetInterfaces"));
00589     }
00590 
00591 Q_SIGNALS:
00599     void Closed();
00600 
00601 protected:
00602     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00603 };
00604 
00612 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
00613 {
00614     Q_OBJECT
00615 
00616 public:
00623     static inline const char *staticInterfaceName()
00624     {
00625         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
00626     }
00627 
00635     ChannelInterfaceCallStateInterface(
00636         const QString& busName,
00637         const QString& objectPath,
00638         QObject* parent = 0
00639     );
00640 
00649     ChannelInterfaceCallStateInterface(
00650         const QDBusConnection& connection,
00651         const QString& busName,
00652         const QString& objectPath,
00653         QObject* parent = 0
00654     );
00655 
00662     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
00663 
00671     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00672 
00680     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00681 
00682 public Q_SLOTS:
00693     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
00694     {
00695         if (!invalidationReason().isEmpty()) {
00696             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
00697                 invalidationReason(),
00698                 invalidationMessage()
00699             ));
00700         }
00701 
00702 
00703         return asyncCall(QLatin1String("GetCallStates"));
00704     }
00705 
00706 Q_SIGNALS:
00720     void CallStateChanged(uint contact, uint state);
00721 
00722 protected:
00723     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00724 };
00725 
00733 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
00734 {
00735     Q_OBJECT
00736 
00737 public:
00744     static inline const char *staticInterfaceName()
00745     {
00746         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
00747     }
00748 
00756     ChannelInterfaceChatStateInterface(
00757         const QString& busName,
00758         const QString& objectPath,
00759         QObject* parent = 0
00760     );
00761 
00770     ChannelInterfaceChatStateInterface(
00771         const QDBusConnection& connection,
00772         const QString& busName,
00773         const QString& objectPath,
00774         QObject* parent = 0
00775     );
00776 
00783     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
00784 
00792     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
00793 
00801     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00802 
00803 public Q_SLOTS:
00814     inline QDBusPendingReply<> SetChatState(uint state)
00815     {
00816         if (!invalidationReason().isEmpty()) {
00817             return QDBusPendingReply<>(QDBusMessage::createError(
00818                 invalidationReason(),
00819                 invalidationMessage()
00820             ));
00821         }
00822 
00823 
00824         QList<QVariant> argumentList;
00825         argumentList << QVariant::fromValue(state);
00826         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
00827     }
00828 
00829 Q_SIGNALS:
00844     void ChatStateChanged(uint contact, uint state);
00845 
00846 protected:
00847     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00848 };
00849 
00857 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
00858 {
00859     Q_OBJECT
00860 
00861 public:
00868     static inline const char *staticInterfaceName()
00869     {
00870         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
00871     }
00872 
00880     ChannelInterfaceDTMFInterface(
00881         const QString& busName,
00882         const QString& objectPath,
00883         QObject* parent = 0
00884     );
00885 
00894     ChannelInterfaceDTMFInterface(
00895         const QDBusConnection& connection,
00896         const QString& busName,
00897         const QString& objectPath,
00898         QObject* parent = 0
00899     );
00900 
00907     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
00908 
00916     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
00917 
00925     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
00926 
00927 public Q_SLOTS:
00945     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
00946     {
00947         if (!invalidationReason().isEmpty()) {
00948             return QDBusPendingReply<>(QDBusMessage::createError(
00949                 invalidationReason(),
00950                 invalidationMessage()
00951             ));
00952         }
00953 
00954 
00955         QList<QVariant> argumentList;
00956         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
00957         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
00958     }
00959 
00970     inline QDBusPendingReply<> StopTone(uint streamID)
00971     {
00972         if (!invalidationReason().isEmpty()) {
00973             return QDBusPendingReply<>(QDBusMessage::createError(
00974                 invalidationReason(),
00975                 invalidationMessage()
00976             ));
00977         }
00978 
00979 
00980         QList<QVariant> argumentList;
00981         argumentList << QVariant::fromValue(streamID);
00982         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
00983     }
00984 
00985 protected:
00986     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
00987 };
00988 
00996 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
00997 {
00998     Q_OBJECT
00999 
01000 public:
01007     static inline const char *staticInterfaceName()
01008     {
01009         return "org.freedesktop.Telepathy.Channel.Interface.Group";
01010     }
01011 
01019     ChannelInterfaceGroupInterface(
01020         const QString& busName,
01021         const QString& objectPath,
01022         QObject* parent = 0
01023     );
01024 
01033     ChannelInterfaceGroupInterface(
01034         const QDBusConnection& connection,
01035         const QString& busName,
01036         const QString& objectPath,
01037         QObject* parent = 0
01038     );
01039 
01046     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
01047 
01055     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
01056 
01064     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01065 
01074     Q_PROPERTY(uint GroupFlags READ GroupFlags)
01075 
01076     
01084     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
01085     {
01086         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
01087     }
01088 
01100     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
01101 
01102     
01110     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
01111     {
01112         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
01113     }
01114 
01121     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
01122 
01123     
01131     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
01132     {
01133         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
01134     }
01135 
01141     Q_PROPERTY(Tp::UIntList Members READ Members)
01142 
01143     
01151     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
01152     {
01153         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
01154     }
01155 
01162     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
01163 
01164     
01172     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
01173     {
01174         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
01175     }
01176 
01187     Q_PROPERTY(uint SelfHandle READ SelfHandle)
01188 
01189     
01197     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
01198     {
01199         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
01200     }
01201 
01202 public Q_SLOTS:
01226     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
01227     {
01228         if (!invalidationReason().isEmpty()) {
01229             return QDBusPendingReply<>(QDBusMessage::createError(
01230                 invalidationReason(),
01231                 invalidationMessage()
01232             ));
01233         }
01234 
01235 
01236         QList<QVariant> argumentList;
01237         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01238         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
01239     }
01240 
01258     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
01259     {
01260         if (!invalidationReason().isEmpty()) {
01261             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
01262                 invalidationReason(),
01263                 invalidationMessage()
01264             ));
01265         }
01266 
01267 
01268         return asyncCall(QLatin1String("GetAllMembers"));
01269     }
01270 
01280     inline QDBusPendingReply<uint> GetGroupFlags()
01281     {
01282         if (!invalidationReason().isEmpty()) {
01283             return QDBusPendingReply<uint>(QDBusMessage::createError(
01284                 invalidationReason(),
01285                 invalidationMessage()
01286             ));
01287         }
01288 
01289 
01290         return asyncCall(QLatin1String("GetGroupFlags"));
01291     }
01292 
01313     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
01314     {
01315         if (!invalidationReason().isEmpty()) {
01316             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01317                 invalidationReason(),
01318                 invalidationMessage()
01319             ));
01320         }
01321 
01322 
01323         QList<QVariant> argumentList;
01324         argumentList << QVariant::fromValue(handles);
01325         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
01326     }
01327 
01334     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
01335     {
01336         if (!invalidationReason().isEmpty()) {
01337             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01338                 invalidationReason(),
01339                 invalidationMessage()
01340             ));
01341         }
01342 
01343 
01344         return asyncCall(QLatin1String("GetLocalPendingMembers"));
01345     }
01346 
01360     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
01361     {
01362         if (!invalidationReason().isEmpty()) {
01363             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
01364                 invalidationReason(),
01365                 invalidationMessage()
01366             ));
01367         }
01368 
01369 
01370         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
01371     }
01372 
01378     inline QDBusPendingReply<Tp::UIntList> GetMembers()
01379     {
01380         if (!invalidationReason().isEmpty()) {
01381             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01382                 invalidationReason(),
01383                 invalidationMessage()
01384             ));
01385         }
01386 
01387 
01388         return asyncCall(QLatin1String("GetMembers"));
01389     }
01390 
01397     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
01398     {
01399         if (!invalidationReason().isEmpty()) {
01400             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
01401                 invalidationReason(),
01402                 invalidationMessage()
01403             ));
01404         }
01405 
01406 
01407         return asyncCall(QLatin1String("GetRemotePendingMembers"));
01408     }
01409 
01415     inline QDBusPendingReply<uint> GetSelfHandle()
01416     {
01417         if (!invalidationReason().isEmpty()) {
01418             return QDBusPendingReply<uint>(QDBusMessage::createError(
01419                 invalidationReason(),
01420                 invalidationMessage()
01421             ));
01422         }
01423 
01424 
01425         return asyncCall(QLatin1String("GetSelfHandle"));
01426     }
01427 
01476     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
01477     {
01478         if (!invalidationReason().isEmpty()) {
01479             return QDBusPendingReply<>(QDBusMessage::createError(
01480                 invalidationReason(),
01481                 invalidationMessage()
01482             ));
01483         }
01484 
01485 
01486         QList<QVariant> argumentList;
01487         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
01488         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
01489     }
01490 
01510     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
01511     {
01512         if (!invalidationReason().isEmpty()) {
01513             return QDBusPendingReply<>(QDBusMessage::createError(
01514                 invalidationReason(),
01515                 invalidationMessage()
01516             ));
01517         }
01518 
01519 
01520         QList<QVariant> argumentList;
01521         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
01522         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
01523     }
01524 
01525 Q_SIGNALS:
01544     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
01545 
01555     void SelfHandleChanged(uint selfHandle);
01556 
01571     void GroupFlagsChanged(uint added, uint removed);
01572 
01620     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);
01621 
01722     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
01723 
01724 protected:
01725     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01726 };
01727 
01735 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
01736 {
01737     Q_OBJECT
01738 
01739 public:
01746     static inline const char *staticInterfaceName()
01747     {
01748         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
01749     }
01750 
01758     ChannelInterfaceHoldInterface(
01759         const QString& busName,
01760         const QString& objectPath,
01761         QObject* parent = 0
01762     );
01763 
01772     ChannelInterfaceHoldInterface(
01773         const QDBusConnection& connection,
01774         const QString& busName,
01775         const QString& objectPath,
01776         QObject* parent = 0
01777     );
01778 
01785     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
01786 
01794     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
01795 
01803     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
01804 
01805 public Q_SLOTS:
01819     inline QDBusPendingReply<uint, uint> GetHoldState()
01820     {
01821         if (!invalidationReason().isEmpty()) {
01822             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
01823                 invalidationReason(),
01824                 invalidationMessage()
01825             ));
01826         }
01827 
01828 
01829         return asyncCall(QLatin1String("GetHoldState"));
01830     }
01831 
01888     inline QDBusPendingReply<> RequestHold(bool hold)
01889     {
01890         if (!invalidationReason().isEmpty()) {
01891             return QDBusPendingReply<>(QDBusMessage::createError(
01892                 invalidationReason(),
01893                 invalidationMessage()
01894             ));
01895         }
01896 
01897 
01898         QList<QVariant> argumentList;
01899         argumentList << QVariant::fromValue(hold);
01900         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
01901     }
01902 
01903 Q_SIGNALS:
01920     void HoldStateChanged(uint holdState, uint reason);
01921 
01922 protected:
01923     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
01924 };
01925 
01933 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
01934 {
01935     Q_OBJECT
01936 
01937 public:
01944     static inline const char *staticInterfaceName()
01945     {
01946         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
01947     }
01948 
01956     ChannelInterfaceMediaSignallingInterface(
01957         const QString& busName,
01958         const QString& objectPath,
01959         QObject* parent = 0
01960     );
01961 
01970     ChannelInterfaceMediaSignallingInterface(
01971         const QDBusConnection& connection,
01972         const QString& busName,
01973         const QString& objectPath,
01974         QObject* parent = 0
01975     );
01976 
01983     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
01984 
01992     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
01993 
02001     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02002 
02003 public Q_SLOTS:
02010     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
02011     {
02012         if (!invalidationReason().isEmpty()) {
02013             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
02014                 invalidationReason(),
02015                 invalidationMessage()
02016             ));
02017         }
02018 
02019 
02020         return asyncCall(QLatin1String("GetSessionHandlers"));
02021     }
02022 
02023 Q_SIGNALS:
02039     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
02040 
02041 protected:
02042     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02043 };
02044 
02052 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
02053 {
02054     Q_OBJECT
02055 
02056 public:
02063     static inline const char *staticInterfaceName()
02064     {
02065         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
02066     }
02067 
02075     ChannelInterfaceMessagesInterface(
02076         const QString& busName,
02077         const QString& objectPath,
02078         QObject* parent = 0
02079     );
02080 
02089     ChannelInterfaceMessagesInterface(
02090         const QDBusConnection& connection,
02091         const QString& busName,
02092         const QString& objectPath,
02093         QObject* parent = 0
02094     );
02095 
02102     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
02103 
02111     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
02112 
02120     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02121 
02167     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
02168 
02169     
02177     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
02178     {
02179         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
02180     }
02181 
02187     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
02188 
02189     
02197     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
02198     {
02199         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
02200     }
02201 
02211     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
02212 
02213     
02221     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
02222     {
02223         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
02224     }
02225 
02231     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
02232 
02233     
02241     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
02242     {
02243         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
02244     }
02245 
02246 public Q_SLOTS:
02286     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
02287     {
02288         if (!invalidationReason().isEmpty()) {
02289             return QDBusPendingReply<QString>(QDBusMessage::createError(
02290                 invalidationReason(),
02291                 invalidationMessage()
02292             ));
02293         }
02294 
02295 
02296         QList<QVariant> argumentList;
02297         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
02298         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
02299     }
02300 
02334     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
02335     {
02336         if (!invalidationReason().isEmpty()) {
02337             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
02338                 invalidationReason(),
02339                 invalidationMessage()
02340             ));
02341         }
02342 
02343 
02344         QList<QVariant> argumentList;
02345         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
02346         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
02347     }
02348 
02349 Q_SIGNALS:
02395     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
02396 
02410     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
02411 
02426     void MessageReceived(const Tp::MessagePartList& message);
02427 
02428 protected:
02429     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02430 };
02431 
02439 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
02440 {
02441     Q_OBJECT
02442 
02443 public:
02450     static inline const char *staticInterfaceName()
02451     {
02452         return "org.freedesktop.Telepathy.Channel.Interface.Password";
02453     }
02454 
02462     ChannelInterfacePasswordInterface(
02463         const QString& busName,
02464         const QString& objectPath,
02465         QObject* parent = 0
02466     );
02467 
02476     ChannelInterfacePasswordInterface(
02477         const QDBusConnection& connection,
02478         const QString& busName,
02479         const QString& objectPath,
02480         QObject* parent = 0
02481     );
02482 
02489     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
02490 
02498     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
02499 
02507     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02508 
02509 public Q_SLOTS:
02522     inline QDBusPendingReply<uint> GetPasswordFlags()
02523     {
02524         if (!invalidationReason().isEmpty()) {
02525             return QDBusPendingReply<uint>(QDBusMessage::createError(
02526                 invalidationReason(),
02527                 invalidationMessage()
02528             ));
02529         }
02530 
02531 
02532         return asyncCall(QLatin1String("GetPasswordFlags"));
02533     }
02534 
02550     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
02551     {
02552         if (!invalidationReason().isEmpty()) {
02553             return QDBusPendingReply<bool>(QDBusMessage::createError(
02554                 invalidationReason(),
02555                 invalidationMessage()
02556             ));
02557         }
02558 
02559 
02560         QList<QVariant> argumentList;
02561         argumentList << QVariant::fromValue(password);
02562         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
02563     }
02564 
02565 Q_SIGNALS:
02580     void PasswordFlagsChanged(uint added, uint removed);
02581 
02582 protected:
02583     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02584 };
02585 
02593 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
02594 {
02595     Q_OBJECT
02596 
02597 public:
02604     static inline const char *staticInterfaceName()
02605     {
02606         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
02607     }
02608 
02616     ChannelInterfaceTubeInterface(
02617         const QString& busName,
02618         const QString& objectPath,
02619         QObject* parent = 0
02620     );
02621 
02630     ChannelInterfaceTubeInterface(
02631         const QDBusConnection& connection,
02632         const QString& busName,
02633         const QString& objectPath,
02634         QObject* parent = 0
02635     );
02636 
02643     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
02644 
02652     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
02653 
02661     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02662 
02702     Q_PROPERTY(QVariantMap Parameters READ Parameters)
02703 
02704     
02712     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
02713     {
02714         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
02715     }
02716 
02726     Q_PROPERTY(uint State READ State)
02727 
02728     
02736     inline uint State() const TELEPATHY_GNUC_DEPRECATED
02737     {
02738         return qvariant_cast<uint>(internalPropGet("State"));
02739     }
02740 
02741 Q_SIGNALS:
02752     void TubeChannelStateChanged(uint state);
02753 
02754 protected:
02755     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02756 };
02757 
02765 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
02766 {
02767     Q_OBJECT
02768 
02769 public:
02776     static inline const char *staticInterfaceName()
02777     {
02778         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
02779     }
02780 
02788     ChannelTypeContactListInterface(
02789         const QString& busName,
02790         const QString& objectPath,
02791         QObject* parent = 0
02792     );
02793 
02802     ChannelTypeContactListInterface(
02803         const QDBusConnection& connection,
02804         const QString& busName,
02805         const QString& objectPath,
02806         QObject* parent = 0
02807     );
02808 
02815     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
02816 
02824     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
02825 
02833     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02834 
02835 protected:
02836     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
02837 };
02838 
02846 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
02847 {
02848     Q_OBJECT
02849 
02850 public:
02857     static inline const char *staticInterfaceName()
02858     {
02859         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
02860     }
02861 
02869     ChannelTypeFileTransferInterface(
02870         const QString& busName,
02871         const QString& objectPath,
02872         QObject* parent = 0
02873     );
02874 
02883     ChannelTypeFileTransferInterface(
02884         const QDBusConnection& connection,
02885         const QString& busName,
02886         const QString& objectPath,
02887         QObject* parent = 0
02888     );
02889 
02896     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
02897 
02905     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
02906 
02914     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
02915 
02922     Q_PROPERTY(uint State READ State)
02923 
02924     
02932     inline uint State() const TELEPATHY_GNUC_DEPRECATED
02933     {
02934         return qvariant_cast<uint>(internalPropGet("State"));
02935     }
02936 
02948     Q_PROPERTY(QString ContentType READ ContentType)
02949 
02950     
02958     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
02959     {
02960         return qvariant_cast<QString>(internalPropGet("ContentType"));
02961     }
02962 
02978     Q_PROPERTY(QString Filename READ Filename)
02979 
02980     
02988     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
02989     {
02990         return qvariant_cast<QString>(internalPropGet("Filename"));
02991     }
02992 
03010     Q_PROPERTY(qulonglong Size READ Size)
03011 
03012     
03020     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
03021     {
03022         return qvariant_cast<qulonglong>(internalPropGet("Size"));
03023     }
03024 
03045     Q_PROPERTY(uint ContentHashType READ ContentHashType)
03046 
03047     
03055     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
03056     {
03057         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
03058     }
03059 
03074     Q_PROPERTY(QString ContentHash READ ContentHash)
03075 
03076     
03084     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
03085     {
03086         return qvariant_cast<QString>(internalPropGet("ContentHash"));
03087     }
03088 
03100     Q_PROPERTY(QString Description READ Description)
03101 
03102     
03110     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
03111     {
03112         return qvariant_cast<QString>(internalPropGet("Description"));
03113     }
03114 
03125     Q_PROPERTY(qlonglong Date READ Date)
03126 
03127     
03135     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
03136     {
03137         return qvariant_cast<qlonglong>(internalPropGet("Date"));
03138     }
03139 
03162     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
03163 
03164     
03172     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
03173     {
03174         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
03175     }
03176 
03184     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
03185 
03186     
03194     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
03195     {
03196         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
03197     }
03198 
03215     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
03216 
03217     
03225     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
03226     {
03227         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
03228     }
03229 
03230 public Q_SLOTS:
03270     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
03271     {
03272         if (!invalidationReason().isEmpty()) {
03273             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03274                 invalidationReason(),
03275                 invalidationMessage()
03276             ));
03277         }
03278 
03279 
03280         QList<QVariant> argumentList;
03281         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
03282         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
03283     }
03284 
03313     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
03314     {
03315         if (!invalidationReason().isEmpty()) {
03316             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03317                 invalidationReason(),
03318                 invalidationMessage()
03319             ));
03320         }
03321 
03322 
03323         QList<QVariant> argumentList;
03324         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
03325         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
03326     }
03327 
03328 Q_SIGNALS:
03346     void FileTransferStateChanged(uint state, uint reason);
03347 
03360     void TransferredBytesChanged(qulonglong count);
03361 
03373     void InitialOffsetDefined(qulonglong initialOffset);
03374 
03375 protected:
03376     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03377 };
03378 
03386 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
03387 {
03388     Q_OBJECT
03389 
03390 public:
03397     static inline const char *staticInterfaceName()
03398     {
03399         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
03400     }
03401 
03409     ChannelTypeRoomListInterface(
03410         const QString& busName,
03411         const QString& objectPath,
03412         QObject* parent = 0
03413     );
03414 
03423     ChannelTypeRoomListInterface(
03424         const QDBusConnection& connection,
03425         const QString& busName,
03426         const QString& objectPath,
03427         QObject* parent = 0
03428     );
03429 
03436     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
03437 
03445     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
03446 
03454     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03455 
03465     Q_PROPERTY(QString Server READ Server)
03466 
03467     
03475     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
03476     {
03477         return qvariant_cast<QString>(internalPropGet("Server"));
03478     }
03479 
03480 public Q_SLOTS:
03491     inline QDBusPendingReply<bool> GetListingRooms()
03492     {
03493         if (!invalidationReason().isEmpty()) {
03494             return QDBusPendingReply<bool>(QDBusMessage::createError(
03495                 invalidationReason(),
03496                 invalidationMessage()
03497             ));
03498         }
03499 
03500 
03501         return asyncCall(QLatin1String("GetListingRooms"));
03502     }
03503 
03512     inline QDBusPendingReply<> ListRooms()
03513     {
03514         if (!invalidationReason().isEmpty()) {
03515             return QDBusPendingReply<>(QDBusMessage::createError(
03516                 invalidationReason(),
03517                 invalidationMessage()
03518             ));
03519         }
03520 
03521 
03522         return asyncCall(QLatin1String("ListRooms"));
03523     }
03524 
03532     inline QDBusPendingReply<> StopListing()
03533     {
03534         if (!invalidationReason().isEmpty()) {
03535             return QDBusPendingReply<>(QDBusMessage::createError(
03536                 invalidationReason(),
03537                 invalidationMessage()
03538             ));
03539         }
03540 
03541 
03542         return asyncCall(QLatin1String("StopListing"));
03543     }
03544 
03545 Q_SIGNALS:
03590     void GotRooms(const Tp::RoomInfoList& rooms);
03591 
03602     void ListingRooms(bool listing);
03603 
03604 protected:
03605     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03606 };
03607 
03615 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
03616 {
03617     Q_OBJECT
03618 
03619 public:
03626     static inline const char *staticInterfaceName()
03627     {
03628         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
03629     }
03630 
03638     ChannelTypeStreamTubeInterface(
03639         const QString& busName,
03640         const QString& objectPath,
03641         QObject* parent = 0
03642     );
03643 
03652     ChannelTypeStreamTubeInterface(
03653         const QDBusConnection& connection,
03654         const QString& busName,
03655         const QString& objectPath,
03656         QObject* parent = 0
03657     );
03658 
03665     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
03666 
03674     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
03675 
03683     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
03684 
03701     Q_PROPERTY(QString Service READ Service)
03702 
03703     
03711     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
03712     {
03713         return qvariant_cast<QString>(internalPropGet("Service"));
03714     }
03715 
03744     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
03745 
03746     
03754     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
03755     {
03756         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
03757     }
03758 
03759 public Q_SLOTS:
03785     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
03786     {
03787         if (!invalidationReason().isEmpty()) {
03788             return QDBusPendingReply<>(QDBusMessage::createError(
03789                 invalidationReason(),
03790                 invalidationMessage()
03791             ));
03792         }
03793 
03794 
03795         QList<QVariant> argumentList;
03796         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
03797         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
03798     }
03799 
03833     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
03834     {
03835         if (!invalidationReason().isEmpty()) {
03836             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
03837                 invalidationReason(),
03838                 invalidationMessage()
03839             ));
03840         }
03841 
03842 
03843         QList<QVariant> argumentList;
03844         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
03845         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
03846     }
03847 
03848 Q_SIGNALS:
03885     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
03886 
03900     void NewLocalConnection(uint connectionID);
03901 
03929     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
03930 
03931 protected:
03932     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
03933 };
03934 
03942 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
03943 {
03944     Q_OBJECT
03945 
03946 public:
03953     static inline const char *staticInterfaceName()
03954     {
03955         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
03956     }
03957 
03965     ChannelTypeStreamedMediaInterface(
03966         const QString& busName,
03967         const QString& objectPath,
03968         QObject* parent = 0
03969     );
03970 
03979     ChannelTypeStreamedMediaInterface(
03980         const QDBusConnection& connection,
03981         const QString& busName,
03982         const QString& objectPath,
03983         QObject* parent = 0
03984     );
03985 
03992     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
03993 
04001     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
04002 
04010     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04011 
04094     Q_PROPERTY(bool InitialAudio READ InitialAudio)
04095 
04096     
04104     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
04105     {
04106         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
04107     }
04108 
04123     Q_PROPERTY(bool InitialVideo READ InitialVideo)
04124 
04125     
04133     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
04134     {
04135         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
04136     }
04137 
04174     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
04175 
04176     
04184     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
04185     {
04186         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
04187     }
04188 
04189 public Q_SLOTS:
04210     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
04211     {
04212         if (!invalidationReason().isEmpty()) {
04213             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
04214                 invalidationReason(),
04215                 invalidationMessage()
04216             ));
04217         }
04218 
04219 
04220         return asyncCall(QLatin1String("ListStreams"));
04221     }
04222 
04242     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
04243     {
04244         if (!invalidationReason().isEmpty()) {
04245             return QDBusPendingReply<>(QDBusMessage::createError(
04246                 invalidationReason(),
04247                 invalidationMessage()
04248             ));
04249         }
04250 
04251 
04252         QList<QVariant> argumentList;
04253         argumentList << QVariant::fromValue(streams);
04254         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
04255     }
04256 
04286     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
04287     {
04288         if (!invalidationReason().isEmpty()) {
04289             return QDBusPendingReply<>(QDBusMessage::createError(
04290                 invalidationReason(),
04291                 invalidationMessage()
04292             ));
04293         }
04294 
04295 
04296         QList<QVariant> argumentList;
04297         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
04298         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
04299     }
04300 
04344     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
04345     {
04346         if (!invalidationReason().isEmpty()) {
04347             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
04348                 invalidationReason(),
04349                 invalidationMessage()
04350             ));
04351         }
04352 
04353 
04354         QList<QVariant> argumentList;
04355         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
04356         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
04357     }
04358 
04359 Q_SIGNALS:
04424     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
04425 
04455     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
04456 
04474     void StreamError(uint streamID, uint errorCode, const QString& message);
04475 
04485     void StreamRemoved(uint streamID);
04486 
04500     void StreamStateChanged(uint streamID, uint streamState);
04501 
04502 protected:
04503     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04504 };
04505 
04513 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
04514 {
04515     Q_OBJECT
04516 
04517 public:
04524     static inline const char *staticInterfaceName()
04525     {
04526         return "org.freedesktop.Telepathy.Channel.Type.Text";
04527     }
04528 
04536     ChannelTypeTextInterface(
04537         const QString& busName,
04538         const QString& objectPath,
04539         QObject* parent = 0
04540     );
04541 
04550     ChannelTypeTextInterface(
04551         const QDBusConnection& connection,
04552         const QString& busName,
04553         const QString& objectPath,
04554         QObject* parent = 0
04555     );
04556 
04563     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
04564 
04572     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
04573 
04581     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04582 
04583 public Q_SLOTS:
04594     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
04595     {
04596         if (!invalidationReason().isEmpty()) {
04597             return QDBusPendingReply<>(QDBusMessage::createError(
04598                 invalidationReason(),
04599                 invalidationMessage()
04600             ));
04601         }
04602 
04603 
04604         QList<QVariant> argumentList;
04605         argumentList << QVariant::fromValue(IDs);
04606         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
04607     }
04608 
04619     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
04620     {
04621         if (!invalidationReason().isEmpty()) {
04622             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
04623                 invalidationReason(),
04624                 invalidationMessage()
04625             ));
04626         }
04627 
04628 
04629         return asyncCall(QLatin1String("GetMessageTypes"));
04630     }
04631 
04655     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
04656     {
04657         if (!invalidationReason().isEmpty()) {
04658             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
04659                 invalidationReason(),
04660                 invalidationMessage()
04661             ));
04662         }
04663 
04664 
04665         QList<QVariant> argumentList;
04666         argumentList << QVariant::fromValue(clear);
04667         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
04668     }
04669 
04695     inline QDBusPendingReply<> Send(uint type, const QString& text)
04696     {
04697         if (!invalidationReason().isEmpty()) {
04698             return QDBusPendingReply<>(QDBusMessage::createError(
04699                 invalidationReason(),
04700                 invalidationMessage()
04701             ));
04702         }
04703 
04704 
04705         QList<QVariant> argumentList;
04706         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
04707         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
04708     }
04709 
04710 Q_SIGNALS:
04718     void LostMessage();
04719 
04753     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
04754 
04781     void SendError(uint error, uint timestamp, uint type, const QString& text);
04782 
04804     void Sent(uint timestamp, uint type, const QString& text);
04805 
04806 protected:
04807     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
04808 };
04809 
04817 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
04818 {
04819     Q_OBJECT
04820 
04821 public:
04828     static inline const char *staticInterfaceName()
04829     {
04830         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
04831     }
04832 
04840     ChannelTypeTubesInterface(
04841         const QString& busName,
04842         const QString& objectPath,
04843         QObject* parent = 0
04844     );
04845 
04854     ChannelTypeTubesInterface(
04855         const QDBusConnection& connection,
04856         const QString& busName,
04857         const QString& objectPath,
04858         QObject* parent = 0
04859     );
04860 
04867     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
04868 
04876     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
04877 
04885     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
04886 
04887 public Q_SLOTS:
04917     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
04918     {
04919         if (!invalidationReason().isEmpty()) {
04920             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
04921                 invalidationReason(),
04922                 invalidationMessage()
04923             ));
04924         }
04925 
04926 
04927         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
04928     }
04929 
04938     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
04939     {
04940         if (!invalidationReason().isEmpty()) {
04941             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
04942                 invalidationReason(),
04943                 invalidationMessage()
04944             ));
04945         }
04946 
04947 
04948         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
04949     }
04950 
04961     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
04962     {
04963         if (!invalidationReason().isEmpty()) {
04964             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
04965                 invalidationReason(),
04966                 invalidationMessage()
04967             ));
04968         }
04969 
04970 
04971         return asyncCall(QLatin1String("ListTubes"));
04972     }
04973 
04996     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
04997     {
04998         if (!invalidationReason().isEmpty()) {
04999             return QDBusPendingReply<uint>(QDBusMessage::createError(
05000                 invalidationReason(),
05001                 invalidationMessage()
05002             ));
05003         }
05004 
05005 
05006         QList<QVariant> argumentList;
05007         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
05008         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
05009     }
05010 
05061     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
05062     {
05063         if (!invalidationReason().isEmpty()) {
05064             return QDBusPendingReply<uint>(QDBusMessage::createError(
05065                 invalidationReason(),
05066                 invalidationMessage()
05067             ));
05068         }
05069 
05070 
05071         QList<QVariant> argumentList;
05072         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05073         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
05074     }
05075 
05093     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
05094     {
05095         if (!invalidationReason().isEmpty()) {
05096             return QDBusPendingReply<QString>(QDBusMessage::createError(
05097                 invalidationReason(),
05098                 invalidationMessage()
05099             ));
05100         }
05101 
05102 
05103         QList<QVariant> argumentList;
05104         argumentList << QVariant::fromValue(ID);
05105         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
05106     }
05107 
05140     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
05141     {
05142         if (!invalidationReason().isEmpty()) {
05143             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
05144                 invalidationReason(),
05145                 invalidationMessage()
05146             ));
05147         }
05148 
05149 
05150         QList<QVariant> argumentList;
05151         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
05152         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
05153     }
05154 
05164     inline QDBusPendingReply<> CloseTube(uint ID)
05165     {
05166         if (!invalidationReason().isEmpty()) {
05167             return QDBusPendingReply<>(QDBusMessage::createError(
05168                 invalidationReason(),
05169                 invalidationMessage()
05170             ));
05171         }
05172 
05173 
05174         QList<QVariant> argumentList;
05175         argumentList << QVariant::fromValue(ID);
05176         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
05177     }
05178 
05193     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
05194     {
05195         if (!invalidationReason().isEmpty()) {
05196             return QDBusPendingReply<QString>(QDBusMessage::createError(
05197                 invalidationReason(),
05198                 invalidationMessage()
05199             ));
05200         }
05201 
05202 
05203         QList<QVariant> argumentList;
05204         argumentList << QVariant::fromValue(ID);
05205         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
05206     }
05207 
05223     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
05224     {
05225         if (!invalidationReason().isEmpty()) {
05226             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
05227                 invalidationReason(),
05228                 invalidationMessage()
05229             ));
05230         }
05231 
05232 
05233         QList<QVariant> argumentList;
05234         argumentList << QVariant::fromValue(ID);
05235         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
05236     }
05237 
05258     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
05259     {
05260         if (!invalidationReason().isEmpty()) {
05261             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
05262                 invalidationReason(),
05263                 invalidationMessage()
05264             ));
05265         }
05266 
05267 
05268         QList<QVariant> argumentList;
05269         argumentList << QVariant::fromValue(ID);
05270         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
05271     }
05272 
05273 Q_SIGNALS:
05303     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
05304 
05318     void TubeStateChanged(uint ID, uint state);
05319 
05330     void TubeClosed(uint ID);
05331 
05350     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
05351 
05366     void StreamTubeNewConnection(uint ID, uint handle);
05367 
05368 protected:
05369     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
05370 };
05371 }
05372 }


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