TelepathyQt4: cli-channel.h Source File

| 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
    02546     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
    02547     {
    02548         if (!invalidationReason().isEmpty()) {
    02549             return QDBusPendingReply<bool>(QDBusMessage::createError(
    02550                 invalidationReason(),
    02551                 invalidationMessage()
    02552             ));
    02553         }
    02554
    02555
    02556         QList<QVariant> argumentList;
    02557         argumentList << QVariant::fromValue(password);
    02558         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
    02559     }
    02560
    02561 Q_SIGNALS:
    02576     void PasswordFlagsChanged(uint added, uint removed);
    02577
    02578 protected:
    02579     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02580 };
    02581
    02589 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
    02590 {
    02591     Q_OBJECT
    02592
    02593 public:
    02600     static inline const char *staticInterfaceName()
    02601     {
    02602         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
    02603     }
    02604
    02612     ChannelInterfaceTubeInterface(
    02613         const QString& busName,
    02614         const QString& objectPath,
    02615         QObject* parent = 0
    02616     );
    02617
    02626     ChannelInterfaceTubeInterface(
    02627         const QDBusConnection& connection,
    02628         const QString& busName,
    02629         const QString& objectPath,
    02630         QObject* parent = 0
    02631     );
    02632
    02639     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
    02640
    02648     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    02649
    02657     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02658
    02698     Q_PROPERTY(QVariantMap Parameters READ Parameters)
    02699
    02700
    02708     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
    02709     {
    02710         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
    02711     }
    02712
    02722     Q_PROPERTY(uint State READ State)
    02723
    02724
    02732     inline uint State() const TELEPATHY_GNUC_DEPRECATED
    02733     {
    02734         return qvariant_cast<uint>(internalPropGet("State"));
    02735     }
    02736
    02737 Q_SIGNALS:
    02748     void TubeChannelStateChanged(uint state);
    02749
    02750 protected:
    02751     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02752 };
    02753
    02761 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
    02762 {
    02763     Q_OBJECT
    02764
    02765 public:
    02772     static inline const char *staticInterfaceName()
    02773     {
    02774         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
    02775     }
    02776
    02784     ChannelTypeContactListInterface(
    02785         const QString& busName,
    02786         const QString& objectPath,
    02787         QObject* parent = 0
    02788     );
    02789
    02798     ChannelTypeContactListInterface(
    02799         const QDBusConnection& connection,
    02800         const QString& busName,
    02801         const QString& objectPath,
    02802         QObject* parent = 0
    02803     );
    02804
    02811     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
    02812
    02820     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
    02821
    02829     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02830
    02831 protected:
    02832     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02833 };
    02834
    02842 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
    02843 {
    02844     Q_OBJECT
    02845
    02846 public:
    02853     static inline const char *staticInterfaceName()
    02854     {
    02855         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
    02856     }
    02857
    02865     ChannelTypeFileTransferInterface(
    02866         const QString& busName,
    02867         const QString& objectPath,
    02868         QObject* parent = 0
    02869     );
    02870
    02879     ChannelTypeFileTransferInterface(
    02880         const QDBusConnection& connection,
    02881         const QString& busName,
    02882         const QString& objectPath,
    02883         QObject* parent = 0
    02884     );
    02885
    02892     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
    02893
    02901     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
    02902
    02910     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02911
    02918     Q_PROPERTY(uint State READ State)
    02919
    02920
    02928     inline uint State() const TELEPATHY_GNUC_DEPRECATED
    02929     {
    02930         return qvariant_cast<uint>(internalPropGet("State"));
    02931     }
    02932
    02944     Q_PROPERTY(QString ContentType READ ContentType)
    02945
    02946
    02954     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
    02955     {
    02956         return qvariant_cast<QString>(internalPropGet("ContentType"));
    02957     }
    02958
    02974     Q_PROPERTY(QString Filename READ Filename)
    02975
    02976
    02984     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
    02985     {
    02986         return qvariant_cast<QString>(internalPropGet("Filename"));
    02987     }
    02988
    03006     Q_PROPERTY(qulonglong Size READ Size)
    03007
    03008
    03016     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
    03017     {
    03018         return qvariant_cast<qulonglong>(internalPropGet("Size"));
    03019     }
    03020
    03041     Q_PROPERTY(uint ContentHashType READ ContentHashType)
    03042
    03043
    03051     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
    03052     {
    03053         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
    03054     }
    03055
    03070     Q_PROPERTY(QString ContentHash READ ContentHash)
    03071
    03072
    03080     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
    03081     {
    03082         return qvariant_cast<QString>(internalPropGet("ContentHash"));
    03083     }
    03084
    03096     Q_PROPERTY(QString Description READ Description)
    03097
    03098
    03106     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
    03107     {
    03108         return qvariant_cast<QString>(internalPropGet("Description"));
    03109     }
    03110
    03121     Q_PROPERTY(qlonglong Date READ Date)
    03122
    03123
    03131     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
    03132     {
    03133         return qvariant_cast<qlonglong>(internalPropGet("Date"));
    03134     }
    03135
    03158     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
    03159
    03160
    03168     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
    03169     {
    03170         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
    03171     }
    03172
    03180     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
    03181
    03182
    03190     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
    03191     {
    03192         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
    03193     }
    03194
    03211     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
    03212
    03213
    03221     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
    03222     {
    03223         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
    03224     }
    03225
    03226 public Q_SLOTS:
    03266     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
    03267     {
    03268         if (!invalidationReason().isEmpty()) {
    03269             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    03270                 invalidationReason(),
    03271                 invalidationMessage()
    03272             ));
    03273         }
    03274
    03275
    03276         QList<QVariant> argumentList;
    03277         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
    03278         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
    03279     }
    03280
    03309     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
    03310     {
    03311         if (!invalidationReason().isEmpty()) {
    03312             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    03313                 invalidationReason(),
    03314                 invalidationMessage()
    03315             ));
    03316         }
    03317
    03318
    03319         QList<QVariant> argumentList;
    03320         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    03321         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
    03322     }
    03323
    03324 Q_SIGNALS:
    03342     void FileTransferStateChanged(uint state, uint reason);
    03343
    03356     void TransferredBytesChanged(qulonglong count);
    03357
    03369     void InitialOffsetDefined(qulonglong initialOffset);
    03370
    03371 protected:
    03372     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03373 };
    03374
    03382 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
    03383 {
    03384     Q_OBJECT
    03385
    03386 public:
    03393     static inline const char *staticInterfaceName()
    03394     {
    03395         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
    03396     }
    03397
    03405     ChannelTypeRoomListInterface(
    03406         const QString& busName,
    03407         const QString& objectPath,
    03408         QObject* parent = 0
    03409     );
    03410
    03419     ChannelTypeRoomListInterface(
    03420         const QDBusConnection& connection,
    03421         const QString& busName,
    03422         const QString& objectPath,
    03423         QObject* parent = 0
    03424     );
    03425
    03432     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
    03433
    03441     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
    03442
    03450     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03451
    03461     Q_PROPERTY(QString Server READ Server)
    03462
    03463
    03471     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
    03472     {
    03473         return qvariant_cast<QString>(internalPropGet("Server"));
    03474     }
    03475
    03476 public Q_SLOTS:
    03487     inline QDBusPendingReply<bool> GetListingRooms()
    03488     {
    03489         if (!invalidationReason().isEmpty()) {
    03490             return QDBusPendingReply<bool>(QDBusMessage::createError(
    03491                 invalidationReason(),
    03492                 invalidationMessage()
    03493             ));
    03494         }
    03495
    03496
    03497         return asyncCall(QLatin1String("GetListingRooms"));
    03498     }
    03499
    03508     inline QDBusPendingReply<> ListRooms()
    03509     {
    03510         if (!invalidationReason().isEmpty()) {
    03511             return QDBusPendingReply<>(QDBusMessage::createError(
    03512                 invalidationReason(),
    03513                 invalidationMessage()
    03514             ));
    03515         }
    03516
    03517
    03518         return asyncCall(QLatin1String("ListRooms"));
    03519     }
    03520
    03528     inline QDBusPendingReply<> StopListing()
    03529     {
    03530         if (!invalidationReason().isEmpty()) {
    03531             return QDBusPendingReply<>(QDBusMessage::createError(
    03532                 invalidationReason(),
    03533                 invalidationMessage()
    03534             ));
    03535         }
    03536
    03537
    03538         return asyncCall(QLatin1String("StopListing"));
    03539     }
    03540
    03541 Q_SIGNALS:
    03586     void GotRooms(const Tp::RoomInfoList& rooms);
    03587
    03598     void ListingRooms(bool listing);
    03599
    03600 protected:
    03601     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03602 };
    03603
    03611 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
    03612 {
    03613     Q_OBJECT
    03614
    03615 public:
    03622     static inline const char *staticInterfaceName()
    03623     {
    03624         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
    03625     }
    03626
    03634     ChannelTypeStreamTubeInterface(
    03635         const QString& busName,
    03636         const QString& objectPath,
    03637         QObject* parent = 0
    03638     );
    03639
    03648     ChannelTypeStreamTubeInterface(
    03649         const QDBusConnection& connection,
    03650         const QString& busName,
    03651         const QString& objectPath,
    03652         QObject* parent = 0
    03653     );
    03654
    03661     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
    03662
    03670     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    03671
    03679     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03680
    03697     Q_PROPERTY(QString Service READ Service)
    03698
    03699
    03707     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
    03708     {
    03709         return qvariant_cast<QString>(internalPropGet("Service"));
    03710     }
    03711
    03740     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
    03741
    03742
    03750     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
    03751     {
    03752         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
    03753     }
    03754
    03755 public Q_SLOTS:
    03781     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
    03782     {
    03783         if (!invalidationReason().isEmpty()) {
    03784             return QDBusPendingReply<>(QDBusMessage::createError(
    03785                 invalidationReason(),
    03786                 invalidationMessage()
    03787             ));
    03788         }
    03789
    03790
    03791         QList<QVariant> argumentList;
    03792         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
    03793         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
    03794     }
    03795
    03829     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
    03830     {
    03831         if (!invalidationReason().isEmpty()) {
    03832             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    03833                 invalidationReason(),
    03834                 invalidationMessage()
    03835             ));
    03836         }
    03837
    03838
    03839         QList<QVariant> argumentList;
    03840         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
    03841         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
    03842     }
    03843
    03844 Q_SIGNALS:
    03881     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
    03882
    03896     void NewLocalConnection(uint connectionID);
    03897
    03925     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
    03926
    03927 protected:
    03928     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03929 };
    03930
    03938 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
    03939 {
    03940     Q_OBJECT
    03941
    03942 public:
    03949     static inline const char *staticInterfaceName()
    03950     {
    03951         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
    03952     }
    03953
    03961     ChannelTypeStreamedMediaInterface(
    03962         const QString& busName,
    03963         const QString& objectPath,
    03964         QObject* parent = 0
    03965     );
    03966
    03975     ChannelTypeStreamedMediaInterface(
    03976         const QDBusConnection& connection,
    03977         const QString& busName,
    03978         const QString& objectPath,
    03979         QObject* parent = 0
    03980     );
    03981
    03988     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
    03989
    03997     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
    03998
    04006     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04007
    04090     Q_PROPERTY(bool InitialAudio READ InitialAudio)
    04091
    04092
    04100     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
    04101     {
    04102         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
    04103     }
    04104
    04119     Q_PROPERTY(bool InitialVideo READ InitialVideo)
    04120
    04121
    04129     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
    04130     {
    04131         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
    04132     }
    04133
    04170     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
    04171
    04172
    04180     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
    04181     {
    04182         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
    04183     }
    04184
    04185 public Q_SLOTS:
    04206     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
    04207     {
    04208         if (!invalidationReason().isEmpty()) {
    04209             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    04210                 invalidationReason(),
    04211                 invalidationMessage()
    04212             ));
    04213         }
    04214
    04215
    04216         return asyncCall(QLatin1String("ListStreams"));
    04217     }
    04218
    04238     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
    04239     {
    04240         if (!invalidationReason().isEmpty()) {
    04241             return QDBusPendingReply<>(QDBusMessage::createError(
    04242                 invalidationReason(),
    04243                 invalidationMessage()
    04244             ));
    04245         }
    04246
    04247
    04248         QList<QVariant> argumentList;
    04249         argumentList << QVariant::fromValue(streams);
    04250         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
    04251     }
    04252
    04282     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
    04283     {
    04284         if (!invalidationReason().isEmpty()) {
    04285             return QDBusPendingReply<>(QDBusMessage::createError(
    04286                 invalidationReason(),
    04287                 invalidationMessage()
    04288             ));
    04289         }
    04290
    04291
    04292         QList<QVariant> argumentList;
    04293         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
    04294         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
    04295     }
    04296
    04340     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
    04341     {
    04342         if (!invalidationReason().isEmpty()) {
    04343             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    04344                 invalidationReason(),
    04345                 invalidationMessage()
    04346             ));
    04347         }
    04348
    04349
    04350         QList<QVariant> argumentList;
    04351         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
    04352         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
    04353     }
    04354
    04355 Q_SIGNALS:
    04420     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
    04421
    04451     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
    04452
    04470     void StreamError(uint streamID, uint errorCode, const QString& message);
    04471
    04481     void StreamRemoved(uint streamID);
    04482
    04496     void StreamStateChanged(uint streamID, uint streamState);
    04497
    04498 protected:
    04499     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04500 };
    04501
    04509 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
    04510 {
    04511     Q_OBJECT
    04512
    04513 public:
    04520     static inline const char *staticInterfaceName()
    04521     {
    04522         return "org.freedesktop.Telepathy.Channel.Type.Text";
    04523     }
    04524
    04532     ChannelTypeTextInterface(
    04533         const QString& busName,
    04534         const QString& objectPath,
    04535         QObject* parent = 0
    04536     );
    04537
    04546     ChannelTypeTextInterface(
    04547         const QDBusConnection& connection,
    04548         const QString& busName,
    04549         const QString& objectPath,
    04550         QObject* parent = 0
    04551     );
    04552
    04559     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
    04560
    04568     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
    04569
    04577     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04578
    04579 public Q_SLOTS:
    04590     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
    04591     {
    04592         if (!invalidationReason().isEmpty()) {
    04593             return QDBusPendingReply<>(QDBusMessage::createError(
    04594                 invalidationReason(),
    04595                 invalidationMessage()
    04596             ));
    04597         }
    04598
    04599
    04600         QList<QVariant> argumentList;
    04601         argumentList << QVariant::fromValue(IDs);
    04602         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
    04603     }
    04604
    04615     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
    04616     {
    04617         if (!invalidationReason().isEmpty()) {
    04618             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    04619                 invalidationReason(),
    04620                 invalidationMessage()
    04621             ));
    04622         }
    04623
    04624
    04625         return asyncCall(QLatin1String("GetMessageTypes"));
    04626     }
    04627
    04651     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
    04652     {
    04653         if (!invalidationReason().isEmpty()) {
    04654             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
    04655                 invalidationReason(),
    04656                 invalidationMessage()
    04657             ));
    04658         }
    04659
    04660
    04661         QList<QVariant> argumentList;
    04662         argumentList << QVariant::fromValue(clear);
    04663         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
    04664     }
    04665
    04691     inline QDBusPendingReply<> Send(uint type, const QString& text)
    04692     {
    04693         if (!invalidationReason().isEmpty()) {
    04694             return QDBusPendingReply<>(QDBusMessage::createError(
    04695                 invalidationReason(),
    04696                 invalidationMessage()
    04697             ));
    04698         }
    04699
    04700
    04701         QList<QVariant> argumentList;
    04702         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
    04703         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
    04704     }
    04705
    04706 Q_SIGNALS:
    04714     void LostMessage();
    04715
    04749     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
    04750
    04777     void SendError(uint error, uint timestamp, uint type, const QString& text);
    04778
    04800     void Sent(uint timestamp, uint type, const QString& text);
    04801
    04802 protected:
    04803     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04804 };
    04805
    04813 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
    04814 {
    04815     Q_OBJECT
    04816
    04817 public:
    04824     static inline const char *staticInterfaceName()
    04825     {
    04826         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
    04827     }
    04828
    04836     ChannelTypeTubesInterface(
    04837         const QString& busName,
    04838         const QString& objectPath,
    04839         QObject* parent = 0
    04840     );
    04841
    04850     ChannelTypeTubesInterface(
    04851         const QDBusConnection& connection,
    04852         const QString& busName,
    04853         const QString& objectPath,
    04854         QObject* parent = 0
    04855     );
    04856
    04863     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
    04864
    04872     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
    04873
    04881     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04882
    04883 public Q_SLOTS:
    04913     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
    04914     {
    04915         if (!invalidationReason().isEmpty()) {
    04916             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
    04917                 invalidationReason(),
    04918                 invalidationMessage()
    04919             ));
    04920         }
    04921
    04922
    04923         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
    04924     }
    04925
    04934     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
    04935     {
    04936         if (!invalidationReason().isEmpty()) {
    04937             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    04938                 invalidationReason(),
    04939                 invalidationMessage()
    04940             ));
    04941         }
    04942
    04943
    04944         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
    04945     }
    04946
    04957     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
    04958     {
    04959         if (!invalidationReason().isEmpty()) {
    04960             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
    04961                 invalidationReason(),
    04962                 invalidationMessage()
    04963             ));
    04964         }
    04965
    04966
    04967         return asyncCall(QLatin1String("ListTubes"));
    04968     }
    04969
    04992     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
    04993     {
    04994         if (!invalidationReason().isEmpty()) {
    04995             return QDBusPendingReply<uint>(QDBusMessage::createError(
    04996                 invalidationReason(),
    04997                 invalidationMessage()
    04998             ));
    04999         }
    05000
    05001
    05002         QList<QVariant> argumentList;
    05003         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
    05004         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
    05005     }
    05006
    05057     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
    05058     {
    05059         if (!invalidationReason().isEmpty()) {
    05060             return QDBusPendingReply<uint>(QDBusMessage::createError(
    05061                 invalidationReason(),
    05062                 invalidationMessage()
    05063             ));
    05064         }
    05065
    05066
    05067         QList<QVariant> argumentList;
    05068         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    05069         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
    05070     }
    05071
    05089     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
    05090     {
    05091         if (!invalidationReason().isEmpty()) {
    05092             return QDBusPendingReply<QString>(QDBusMessage::createError(
    05093                 invalidationReason(),
    05094                 invalidationMessage()
    05095             ));
    05096         }
    05097
    05098
    05099         QList<QVariant> argumentList;
    05100         argumentList << QVariant::fromValue(ID);
    05101         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
    05102     }
    05103
    05136     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
    05137     {
    05138         if (!invalidationReason().isEmpty()) {
    05139             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    05140                 invalidationReason(),
    05141                 invalidationMessage()
    05142             ));
    05143         }
    05144
    05145
    05146         QList<QVariant> argumentList;
    05147         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    05148         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
    05149     }
    05150
    05160     inline QDBusPendingReply<> CloseTube(uint ID)
    05161     {
    05162         if (!invalidationReason().isEmpty()) {
    05163             return QDBusPendingReply<>(QDBusMessage::createError(
    05164                 invalidationReason(),
    05165                 invalidationMessage()
    05166             ));
    05167         }
    05168
    05169
    05170         QList<QVariant> argumentList;
    05171         argumentList << QVariant::fromValue(ID);
    05172         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
    05173     }
    05174
    05189     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
    05190     {
    05191         if (!invalidationReason().isEmpty()) {
    05192             return QDBusPendingReply<QString>(QDBusMessage::createError(
    05193                 invalidationReason(),
    05194                 invalidationMessage()
    05195             ));
    05196         }
    05197
    05198
    05199         QList<QVariant> argumentList;
    05200         argumentList << QVariant::fromValue(ID);
    05201         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
    05202     }
    05203
    05219     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
    05220     {
    05221         if (!invalidationReason().isEmpty()) {
    05222             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
    05223                 invalidationReason(),
    05224                 invalidationMessage()
    05225             ));
    05226         }
    05227
    05228
    05229         QList<QVariant> argumentList;
    05230         argumentList << QVariant::fromValue(ID);
    05231         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
    05232     }
    05233
    05254     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
    05255     {
    05256         if (!invalidationReason().isEmpty()) {
    05257             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
    05258                 invalidationReason(),
    05259                 invalidationMessage()
    05260             ));
    05261         }
    05262
    05263
    05264         QList<QVariant> argumentList;
    05265         argumentList << QVariant::fromValue(ID);
    05266         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
    05267     }
    05268
    05269 Q_SIGNALS:
    05299     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
    05300
    05314     void TubeStateChanged(uint ID, uint state);
    05315
    05326     void TubeClosed(uint ID);
    05327
    05346     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
    05347
    05362     void StreamTubeNewConnection(uint ID, uint handle);
    05363
    05364 protected:
    05365     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05366 };
    05367 }
    05368 }