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

# cli-channel.h

    00001 /*
    00002  * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
    00003  *
    00004  * This file can be distributed under the same terms as the specification from
    00005  * which it was generated.
    00006  */
    00007
    00008 #ifndef IN_TELEPATHY_QT4_HEADER
    00009 #error IN_TELEPATHY_QT4_HEADER
    00010 #endif
    00011
    00012 #include <TelepathyQt4/Types>
    00013
    00014 #include <QtGlobal>
    00015
    00016 #include <QString>
    00017 #include <QObject>
    00018 #include <QVariant>
    00019
    00020 #include <QDBusPendingReply>
    00021
    00022 #include <TelepathyQt4/AbstractInterface>
    00023 #include <TelepathyQt4/DBusProxy>
    00024 #include <TelepathyQt4/Global>
    00025
    00026 // basically the same as GLib's G_GNUC_DEPRECATED
    00027 #ifndef TELEPATHY_GNUC_DEPRECATED
    00028 #   if defined(Q_CC_GNUC) && __GNUC__ >= 4
    00029 #       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
    00030 #   else
    00031 #       define TELEPATHY_GNUC_DEPRECATED
    00032 #   endif
    00033 #endif
    00034 namespace Tp
    00035 {
    00036 namespace Client
    00037 {
    00038
    00046 class TELEPATHY_QT4_EXPORT ChannelInterface : public Tp::AbstractInterface
    00047 {
    00048     Q_OBJECT
    00049
    00050 public:
    00057     static inline const char *staticInterfaceName()
    00058     {
    00059         return "org.freedesktop.Telepathy.Channel";
    00060     }
    00061
    00069     ChannelInterface(
    00070         const QString& busName,
    00071         const QString& objectPath,
    00072         QObject* parent = 0
    00073     );
    00074
    00083     ChannelInterface(
    00084         const QDBusConnection& connection,
    00085         const QString& busName,
    00086         const QString& objectPath,
    00087         QObject* parent = 0
    00088     );
    00089
    00096     ChannelInterface(Tp::DBusProxy *proxy);
    00097
    00122     Q_PROPERTY(QString ChannelType READ ChannelType)
    00123
    00124
    00132     inline QString ChannelType() const TELEPATHY_GNUC_DEPRECATED
    00133     {
    00134         return qvariant_cast<QString>(internalPropGet("ChannelType"));
    00135     }
    00136
    00164     Q_PROPERTY(QStringList Interfaces READ Interfaces)
    00165
    00166
    00174     inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
    00175     {
    00176         return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
    00177     }
    00178
    00215     Q_PROPERTY(uint TargetHandle READ TargetHandle)
    00216
    00217
    00225     inline uint TargetHandle() const TELEPATHY_GNUC_DEPRECATED
    00226     {
    00227         return qvariant_cast<uint>(internalPropGet("TargetHandle"));
    00228     }
    00229
    00274     Q_PROPERTY(QString TargetID READ TargetID)
    00275
    00276
    00284     inline QString TargetID() const TELEPATHY_GNUC_DEPRECATED
    00285     {
    00286         return qvariant_cast<QString>(internalPropGet("TargetID"));
    00287     }
    00288
    00302     Q_PROPERTY(uint TargetHandleType READ TargetHandleType)
    00303
    00304
    00312     inline uint TargetHandleType() const TELEPATHY_GNUC_DEPRECATED
    00313     {
    00314         return qvariant_cast<uint>(internalPropGet("TargetHandleType"));
    00315     }
    00316
    00379     Q_PROPERTY(bool Requested READ Requested)
    00380
    00381
    00389     inline bool Requested() const TELEPATHY_GNUC_DEPRECATED
    00390     {
    00391         return qvariant_cast<bool>(internalPropGet("Requested"));
    00392     }
    00393
    00449     Q_PROPERTY(uint InitiatorHandle READ InitiatorHandle)
    00450
    00451
    00459     inline uint InitiatorHandle() const TELEPATHY_GNUC_DEPRECATED
    00460     {
    00461         return qvariant_cast<uint>(internalPropGet("InitiatorHandle"));
    00462     }
    00463
    00492     Q_PROPERTY(QString InitiatorID READ InitiatorID)
    00493
    00494
    00502     inline QString InitiatorID() const TELEPATHY_GNUC_DEPRECATED
    00503     {
    00504         return qvariant_cast<QString>(internalPropGet("InitiatorID"));
    00505     }
    00506
    00507 public Q_SLOTS:
    00517     inline QDBusPendingReply<> Close()
    00518     {
    00519         if (!invalidationReason().isEmpty()) {
    00520             return QDBusPendingReply<>(QDBusMessage::createError(
    00521                 invalidationReason(),
    00522                 invalidationMessage()
    00523             ));
    00524         }
    00525
    00526
    00527         return asyncCall(QLatin1String("Close"));
    00528     }
    00529
    00542     inline QDBusPendingReply<QString> GetChannelType()
    00543     {
    00544         if (!invalidationReason().isEmpty()) {
    00545             return QDBusPendingReply<QString>(QDBusMessage::createError(
    00546                 invalidationReason(),
    00547                 invalidationMessage()
    00548             ));
    00549         }
    00550
    00551
    00552         return asyncCall(QLatin1String("GetChannelType"));
    00553     }
    00554
    00573     inline QDBusPendingReply<uint, uint> GetHandle()
    00574     {
    00575         if (!invalidationReason().isEmpty()) {
    00576             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
    00577                 invalidationReason(),
    00578                 invalidationMessage()
    00579             ));
    00580         }
    00581
    00582
    00583         return asyncCall(QLatin1String("GetHandle"));
    00584     }
    00585
    00598     inline QDBusPendingReply<QStringList> GetInterfaces()
    00599     {
    00600         if (!invalidationReason().isEmpty()) {
    00601             return QDBusPendingReply<QStringList>(QDBusMessage::createError(
    00602                 invalidationReason(),
    00603                 invalidationMessage()
    00604             ));
    00605         }
    00606
    00607
    00608         return asyncCall(QLatin1String("GetInterfaces"));
    00609     }
    00610
    00611 Q_SIGNALS:
    00619     void Closed();
    00620
    00621 protected:
    00622     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    00623 };
    00624
    00632 class TELEPATHY_QT4_EXPORT ChannelInterfaceCallStateInterface : public Tp::AbstractInterface
    00633 {
    00634     Q_OBJECT
    00635
    00636 public:
    00643     static inline const char *staticInterfaceName()
    00644     {
    00645         return "org.freedesktop.Telepathy.Channel.Interface.CallState";
    00646     }
    00647
    00655     ChannelInterfaceCallStateInterface(
    00656         const QString& busName,
    00657         const QString& objectPath,
    00658         QObject* parent = 0
    00659     );
    00660
    00669     ChannelInterfaceCallStateInterface(
    00670         const QDBusConnection& connection,
    00671         const QString& busName,
    00672         const QString& objectPath,
    00673         QObject* parent = 0
    00674     );
    00675
    00682     ChannelInterfaceCallStateInterface(Tp::DBusProxy *proxy);
    00683
    00691     explicit ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface);
    00692
    00700     ChannelInterfaceCallStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    00701
    00702 public Q_SLOTS:
    00713     inline QDBusPendingReply<Tp::ChannelCallStateMap> GetCallStates()
    00714     {
    00715         if (!invalidationReason().isEmpty()) {
    00716             return QDBusPendingReply<Tp::ChannelCallStateMap>(QDBusMessage::createError(
    00717                 invalidationReason(),
    00718                 invalidationMessage()
    00719             ));
    00720         }
    00721
    00722
    00723         return asyncCall(QLatin1String("GetCallStates"));
    00724     }
    00725
    00726 Q_SIGNALS:
    00740     void CallStateChanged(uint contact, uint state);
    00741
    00742 protected:
    00743     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    00744 };
    00745
    00753 class TELEPATHY_QT4_EXPORT ChannelInterfaceChatStateInterface : public Tp::AbstractInterface
    00754 {
    00755     Q_OBJECT
    00756
    00757 public:
    00764     static inline const char *staticInterfaceName()
    00765     {
    00766         return "org.freedesktop.Telepathy.Channel.Interface.ChatState";
    00767     }
    00768
    00776     ChannelInterfaceChatStateInterface(
    00777         const QString& busName,
    00778         const QString& objectPath,
    00779         QObject* parent = 0
    00780     );
    00781
    00790     ChannelInterfaceChatStateInterface(
    00791         const QDBusConnection& connection,
    00792         const QString& busName,
    00793         const QString& objectPath,
    00794         QObject* parent = 0
    00795     );
    00796
    00803     ChannelInterfaceChatStateInterface(Tp::DBusProxy *proxy);
    00804
    00812     explicit ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface);
    00813
    00821     ChannelInterfaceChatStateInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    00822
    00823 public Q_SLOTS:
    00834     inline QDBusPendingReply<> SetChatState(uint state)
    00835     {
    00836         if (!invalidationReason().isEmpty()) {
    00837             return QDBusPendingReply<>(QDBusMessage::createError(
    00838                 invalidationReason(),
    00839                 invalidationMessage()
    00840             ));
    00841         }
    00842
    00843
    00844         QList<QVariant> argumentList;
    00845         argumentList << QVariant::fromValue(state);
    00846         return asyncCallWithArgumentList(QLatin1String("SetChatState"), argumentList);
    00847     }
    00848
    00849 Q_SIGNALS:
    00864     void ChatStateChanged(uint contact, uint state);
    00865
    00866 protected:
    00867     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    00868 };
    00869
    00877 class TELEPATHY_QT4_EXPORT ChannelInterfaceDTMFInterface : public Tp::AbstractInterface
    00878 {
    00879     Q_OBJECT
    00880
    00881 public:
    00888     static inline const char *staticInterfaceName()
    00889     {
    00890         return "org.freedesktop.Telepathy.Channel.Interface.DTMF";
    00891     }
    00892
    00900     ChannelInterfaceDTMFInterface(
    00901         const QString& busName,
    00902         const QString& objectPath,
    00903         QObject* parent = 0
    00904     );
    00905
    00914     ChannelInterfaceDTMFInterface(
    00915         const QDBusConnection& connection,
    00916         const QString& busName,
    00917         const QString& objectPath,
    00918         QObject* parent = 0
    00919     );
    00920
    00927     ChannelInterfaceDTMFInterface(Tp::DBusProxy *proxy);
    00928
    00936     explicit ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface);
    00937
    00945     ChannelInterfaceDTMFInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    00946
    00947 public Q_SLOTS:
    00965     inline QDBusPendingReply<> StartTone(uint streamID, uchar event)
    00966     {
    00967         if (!invalidationReason().isEmpty()) {
    00968             return QDBusPendingReply<>(QDBusMessage::createError(
    00969                 invalidationReason(),
    00970                 invalidationMessage()
    00971             ));
    00972         }
    00973
    00974
    00975         QList<QVariant> argumentList;
    00976         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(event);
    00977         return asyncCallWithArgumentList(QLatin1String("StartTone"), argumentList);
    00978     }
    00979
    00990     inline QDBusPendingReply<> StopTone(uint streamID)
    00991     {
    00992         if (!invalidationReason().isEmpty()) {
    00993             return QDBusPendingReply<>(QDBusMessage::createError(
    00994                 invalidationReason(),
    00995                 invalidationMessage()
    00996             ));
    00997         }
    00998
    00999
    01000         QList<QVariant> argumentList;
    01001         argumentList << QVariant::fromValue(streamID);
    01002         return asyncCallWithArgumentList(QLatin1String("StopTone"), argumentList);
    01003     }
    01004
    01005 protected:
    01006     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01007 };
    01008
    01016 class TELEPATHY_QT4_EXPORT ChannelInterfaceGroupInterface : public Tp::AbstractInterface
    01017 {
    01018     Q_OBJECT
    01019
    01020 public:
    01027     static inline const char *staticInterfaceName()
    01028     {
    01029         return "org.freedesktop.Telepathy.Channel.Interface.Group";
    01030     }
    01031
    01039     ChannelInterfaceGroupInterface(
    01040         const QString& busName,
    01041         const QString& objectPath,
    01042         QObject* parent = 0
    01043     );
    01044
    01053     ChannelInterfaceGroupInterface(
    01054         const QDBusConnection& connection,
    01055         const QString& busName,
    01056         const QString& objectPath,
    01057         QObject* parent = 0
    01058     );
    01059
    01066     ChannelInterfaceGroupInterface(Tp::DBusProxy *proxy);
    01067
    01075     explicit ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface);
    01076
    01084     ChannelInterfaceGroupInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    01085
    01094     Q_PROPERTY(uint GroupFlags READ GroupFlags)
    01095
    01096
    01104     inline uint GroupFlags() const TELEPATHY_GNUC_DEPRECATED
    01105     {
    01106         return qvariant_cast<uint>(internalPropGet("GroupFlags"));
    01107     }
    01108
    01120     Q_PROPERTY(Tp::HandleOwnerMap HandleOwners READ HandleOwners)
    01121
    01122
    01130     inline Tp::HandleOwnerMap HandleOwners() const TELEPATHY_GNUC_DEPRECATED
    01131     {
    01132         return qvariant_cast<Tp::HandleOwnerMap>(internalPropGet("HandleOwners"));
    01133     }
    01134
    01141     Q_PROPERTY(Tp::LocalPendingInfoList LocalPendingMembers READ LocalPendingMembers)
    01142
    01143
    01151     inline Tp::LocalPendingInfoList LocalPendingMembers() const TELEPATHY_GNUC_DEPRECATED
    01152     {
    01153         return qvariant_cast<Tp::LocalPendingInfoList>(internalPropGet("LocalPendingMembers"));
    01154     }
    01155
    01161     Q_PROPERTY(Tp::UIntList Members READ Members)
    01162
    01163
    01171     inline Tp::UIntList Members() const TELEPATHY_GNUC_DEPRECATED
    01172     {
    01173         return qvariant_cast<Tp::UIntList>(internalPropGet("Members"));
    01174     }
    01175
    01182     Q_PROPERTY(Tp::UIntList RemotePendingMembers READ RemotePendingMembers)
    01183
    01184
    01192     inline Tp::UIntList RemotePendingMembers() const TELEPATHY_GNUC_DEPRECATED
    01193     {
    01194         return qvariant_cast<Tp::UIntList>(internalPropGet("RemotePendingMembers"));
    01195     }
    01196
    01207     Q_PROPERTY(uint SelfHandle READ SelfHandle)
    01208
    01209
    01217     inline uint SelfHandle() const TELEPATHY_GNUC_DEPRECATED
    01218     {
    01219         return qvariant_cast<uint>(internalPropGet("SelfHandle"));
    01220     }
    01221
    01222 public Q_SLOTS:
    01246     inline QDBusPendingReply<> AddMembers(const Tp::UIntList& contacts, const QString& message)
    01247     {
    01248         if (!invalidationReason().isEmpty()) {
    01249             return QDBusPendingReply<>(QDBusMessage::createError(
    01250                 invalidationReason(),
    01251                 invalidationMessage()
    01252             ));
    01253         }
    01254
    01255
    01256         QList<QVariant> argumentList;
    01257         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    01258         return asyncCallWithArgumentList(QLatin1String("AddMembers"), argumentList);
    01259     }
    01260
    01278     inline QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList> GetAllMembers()
    01279     {
    01280         if (!invalidationReason().isEmpty()) {
    01281             return QDBusPendingReply<Tp::UIntList, Tp::UIntList, Tp::UIntList>(QDBusMessage::createError(
    01282                 invalidationReason(),
    01283                 invalidationMessage()
    01284             ));
    01285         }
    01286
    01287
    01288         return asyncCall(QLatin1String("GetAllMembers"));
    01289     }
    01290
    01300     inline QDBusPendingReply<uint> GetGroupFlags()
    01301     {
    01302         if (!invalidationReason().isEmpty()) {
    01303             return QDBusPendingReply<uint>(QDBusMessage::createError(
    01304                 invalidationReason(),
    01305                 invalidationMessage()
    01306             ));
    01307         }
    01308
    01309
    01310         return asyncCall(QLatin1String("GetGroupFlags"));
    01311     }
    01312
    01333     inline QDBusPendingReply<Tp::UIntList> GetHandleOwners(const Tp::UIntList& handles)
    01334     {
    01335         if (!invalidationReason().isEmpty()) {
    01336             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    01337                 invalidationReason(),
    01338                 invalidationMessage()
    01339             ));
    01340         }
    01341
    01342
    01343         QList<QVariant> argumentList;
    01344         argumentList << QVariant::fromValue(handles);
    01345         return asyncCallWithArgumentList(QLatin1String("GetHandleOwners"), argumentList);
    01346     }
    01347
    01354     inline QDBusPendingReply<Tp::UIntList> GetLocalPendingMembers()
    01355     {
    01356         if (!invalidationReason().isEmpty()) {
    01357             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    01358                 invalidationReason(),
    01359                 invalidationMessage()
    01360             ));
    01361         }
    01362
    01363
    01364         return asyncCall(QLatin1String("GetLocalPendingMembers"));
    01365     }
    01366
    01380     inline QDBusPendingReply<Tp::LocalPendingInfoList> GetLocalPendingMembersWithInfo()
    01381     {
    01382         if (!invalidationReason().isEmpty()) {
    01383             return QDBusPendingReply<Tp::LocalPendingInfoList>(QDBusMessage::createError(
    01384                 invalidationReason(),
    01385                 invalidationMessage()
    01386             ));
    01387         }
    01388
    01389
    01390         return asyncCall(QLatin1String("GetLocalPendingMembersWithInfo"));
    01391     }
    01392
    01398     inline QDBusPendingReply<Tp::UIntList> GetMembers()
    01399     {
    01400         if (!invalidationReason().isEmpty()) {
    01401             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    01402                 invalidationReason(),
    01403                 invalidationMessage()
    01404             ));
    01405         }
    01406
    01407
    01408         return asyncCall(QLatin1String("GetMembers"));
    01409     }
    01410
    01417     inline QDBusPendingReply<Tp::UIntList> GetRemotePendingMembers()
    01418     {
    01419         if (!invalidationReason().isEmpty()) {
    01420             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    01421                 invalidationReason(),
    01422                 invalidationMessage()
    01423             ));
    01424         }
    01425
    01426
    01427         return asyncCall(QLatin1String("GetRemotePendingMembers"));
    01428     }
    01429
    01435     inline QDBusPendingReply<uint> GetSelfHandle()
    01436     {
    01437         if (!invalidationReason().isEmpty()) {
    01438             return QDBusPendingReply<uint>(QDBusMessage::createError(
    01439                 invalidationReason(),
    01440                 invalidationMessage()
    01441             ));
    01442         }
    01443
    01444
    01445         return asyncCall(QLatin1String("GetSelfHandle"));
    01446     }
    01447
    01496     inline QDBusPendingReply<> RemoveMembers(const Tp::UIntList& contacts, const QString& message)
    01497     {
    01498         if (!invalidationReason().isEmpty()) {
    01499             return QDBusPendingReply<>(QDBusMessage::createError(
    01500                 invalidationReason(),
    01501                 invalidationMessage()
    01502             ));
    01503         }
    01504
    01505
    01506         QList<QVariant> argumentList;
    01507         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message);
    01508         return asyncCallWithArgumentList(QLatin1String("RemoveMembers"), argumentList);
    01509     }
    01510
    01530     inline QDBusPendingReply<> RemoveMembersWithReason(const Tp::UIntList& contacts, const QString& message, uint reason)
    01531     {
    01532         if (!invalidationReason().isEmpty()) {
    01533             return QDBusPendingReply<>(QDBusMessage::createError(
    01534                 invalidationReason(),
    01535                 invalidationMessage()
    01536             ));
    01537         }
    01538
    01539
    01540         QList<QVariant> argumentList;
    01541         argumentList << QVariant::fromValue(contacts) << QVariant::fromValue(message) << QVariant::fromValue(reason);
    01542         return asyncCallWithArgumentList(QLatin1String("RemoveMembersWithReason"), argumentList);
    01543     }
    01544
    01545 Q_SIGNALS:
    01564     void HandleOwnersChanged(const Tp::HandleOwnerMap& added, const Tp::UIntList& removed);
    01565
    01575     void SelfHandleChanged(uint selfHandle);
    01576
    01591     void GroupFlagsChanged(uint added, uint removed);
    01592
    01640     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);
    01641
    01742     void MembersChangedDetailed(const Tp::UIntList& added, const Tp::UIntList& removed, const Tp::UIntList& localPending, const Tp::UIntList& remotePending, const QVariantMap& details);
    01743
    01744 protected:
    01745     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01746 };
    01747
    01755 class TELEPATHY_QT4_EXPORT ChannelInterfaceHoldInterface : public Tp::AbstractInterface
    01756 {
    01757     Q_OBJECT
    01758
    01759 public:
    01766     static inline const char *staticInterfaceName()
    01767     {
    01768         return "org.freedesktop.Telepathy.Channel.Interface.Hold";
    01769     }
    01770
    01778     ChannelInterfaceHoldInterface(
    01779         const QString& busName,
    01780         const QString& objectPath,
    01781         QObject* parent = 0
    01782     );
    01783
    01792     ChannelInterfaceHoldInterface(
    01793         const QDBusConnection& connection,
    01794         const QString& busName,
    01795         const QString& objectPath,
    01796         QObject* parent = 0
    01797     );
    01798
    01805     ChannelInterfaceHoldInterface(Tp::DBusProxy *proxy);
    01806
    01814     explicit ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface);
    01815
    01823     ChannelInterfaceHoldInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    01824
    01825 public Q_SLOTS:
    01839     inline QDBusPendingReply<uint, uint> GetHoldState()
    01840     {
    01841         if (!invalidationReason().isEmpty()) {
    01842             return QDBusPendingReply<uint, uint>(QDBusMessage::createError(
    01843                 invalidationReason(),
    01844                 invalidationMessage()
    01845             ));
    01846         }
    01847
    01848
    01849         return asyncCall(QLatin1String("GetHoldState"));
    01850     }
    01851
    01908     inline QDBusPendingReply<> RequestHold(bool hold)
    01909     {
    01910         if (!invalidationReason().isEmpty()) {
    01911             return QDBusPendingReply<>(QDBusMessage::createError(
    01912                 invalidationReason(),
    01913                 invalidationMessage()
    01914             ));
    01915         }
    01916
    01917
    01918         QList<QVariant> argumentList;
    01919         argumentList << QVariant::fromValue(hold);
    01920         return asyncCallWithArgumentList(QLatin1String("RequestHold"), argumentList);
    01921     }
    01922
    01923 Q_SIGNALS:
    01940     void HoldStateChanged(uint holdState, uint reason);
    01941
    01942 protected:
    01943     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    01944 };
    01945
    01953 class TELEPATHY_QT4_EXPORT ChannelInterfaceMediaSignallingInterface : public Tp::AbstractInterface
    01954 {
    01955     Q_OBJECT
    01956
    01957 public:
    01964     static inline const char *staticInterfaceName()
    01965     {
    01966         return "org.freedesktop.Telepathy.Channel.Interface.MediaSignalling";
    01967     }
    01968
    01976     ChannelInterfaceMediaSignallingInterface(
    01977         const QString& busName,
    01978         const QString& objectPath,
    01979         QObject* parent = 0
    01980     );
    01981
    01990     ChannelInterfaceMediaSignallingInterface(
    01991         const QDBusConnection& connection,
    01992         const QString& busName,
    01993         const QString& objectPath,
    01994         QObject* parent = 0
    01995     );
    01996
    02003     ChannelInterfaceMediaSignallingInterface(Tp::DBusProxy *proxy);
    02004
    02012     explicit ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface);
    02013
    02021     ChannelInterfaceMediaSignallingInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02022
    02023 public Q_SLOTS:
    02030     inline QDBusPendingReply<Tp::MediaSessionHandlerInfoList> GetSessionHandlers()
    02031     {
    02032         if (!invalidationReason().isEmpty()) {
    02033             return QDBusPendingReply<Tp::MediaSessionHandlerInfoList>(QDBusMessage::createError(
    02034                 invalidationReason(),
    02035                 invalidationMessage()
    02036             ));
    02037         }
    02038
    02039
    02040         return asyncCall(QLatin1String("GetSessionHandlers"));
    02041     }
    02042
    02043 Q_SIGNALS:
    02059     void NewSessionHandler(const QDBusObjectPath& sessionHandler, const QString& sessionType);
    02060
    02061 protected:
    02062     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02063 };
    02064
    02072 class TELEPATHY_QT4_EXPORT ChannelInterfaceMessagesInterface : public Tp::AbstractInterface
    02073 {
    02074     Q_OBJECT
    02075
    02076 public:
    02083     static inline const char *staticInterfaceName()
    02084     {
    02085         return "org.freedesktop.Telepathy.Channel.Interface.Messages";
    02086     }
    02087
    02095     ChannelInterfaceMessagesInterface(
    02096         const QString& busName,
    02097         const QString& objectPath,
    02098         QObject* parent = 0
    02099     );
    02100
    02109     ChannelInterfaceMessagesInterface(
    02110         const QDBusConnection& connection,
    02111         const QString& busName,
    02112         const QString& objectPath,
    02113         QObject* parent = 0
    02114     );
    02115
    02122     ChannelInterfaceMessagesInterface(Tp::DBusProxy *proxy);
    02123
    02131     explicit ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface);
    02132
    02140     ChannelInterfaceMessagesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02141
    02187     Q_PROPERTY(QStringList SupportedContentTypes READ SupportedContentTypes)
    02188
    02189
    02197     inline QStringList SupportedContentTypes() const TELEPATHY_GNUC_DEPRECATED
    02198     {
    02199         return qvariant_cast<QStringList>(internalPropGet("SupportedContentTypes"));
    02200     }
    02201
    02207     Q_PROPERTY(uint MessagePartSupportFlags READ MessagePartSupportFlags)
    02208
    02209
    02217     inline uint MessagePartSupportFlags() const TELEPATHY_GNUC_DEPRECATED
    02218     {
    02219         return qvariant_cast<uint>(internalPropGet("MessagePartSupportFlags"));
    02220     }
    02221
    02231     Q_PROPERTY(Tp::MessagePartListList PendingMessages READ PendingMessages)
    02232
    02233
    02241     inline Tp::MessagePartListList PendingMessages() const TELEPATHY_GNUC_DEPRECATED
    02242     {
    02243         return qvariant_cast<Tp::MessagePartListList>(internalPropGet("PendingMessages"));
    02244     }
    02245
    02251     Q_PROPERTY(uint DeliveryReportingSupport READ DeliveryReportingSupport)
    02252
    02253
    02261     inline uint DeliveryReportingSupport() const TELEPATHY_GNUC_DEPRECATED
    02262     {
    02263         return qvariant_cast<uint>(internalPropGet("DeliveryReportingSupport"));
    02264     }
    02265
    02266 public Q_SLOTS:
    02306     inline QDBusPendingReply<QString> SendMessage(const Tp::MessagePartList& message, uint flags)
    02307     {
    02308         if (!invalidationReason().isEmpty()) {
    02309             return QDBusPendingReply<QString>(QDBusMessage::createError(
    02310                 invalidationReason(),
    02311                 invalidationMessage()
    02312             ));
    02313         }
    02314
    02315
    02316         QList<QVariant> argumentList;
    02317         argumentList << QVariant::fromValue(message) << QVariant::fromValue(flags);
    02318         return asyncCallWithArgumentList(QLatin1String("SendMessage"), argumentList);
    02319     }
    02320
    02354     inline QDBusPendingReply<Tp::MessagePartContentMap> GetPendingMessageContent(uint messageID, const Tp::UIntList& parts)
    02355     {
    02356         if (!invalidationReason().isEmpty()) {
    02357             return QDBusPendingReply<Tp::MessagePartContentMap>(QDBusMessage::createError(
    02358                 invalidationReason(),
    02359                 invalidationMessage()
    02360             ));
    02361         }
    02362
    02363
    02364         QList<QVariant> argumentList;
    02365         argumentList << QVariant::fromValue(messageID) << QVariant::fromValue(parts);
    02366         return asyncCallWithArgumentList(QLatin1String("GetPendingMessageContent"), argumentList);
    02367     }
    02368
    02369 Q_SIGNALS:
    02416     void MessageSent(const Tp::MessagePartList& content, uint flags, const QString& messageToken);
    02417
    02431     void PendingMessagesRemoved(const Tp::UIntList& messageIDs);
    02432
    02447     void MessageReceived(const Tp::MessagePartList& message);
    02448
    02449 protected:
    02450     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02451 };
    02452
    02460 class TELEPATHY_QT4_EXPORT ChannelInterfacePasswordInterface : public Tp::AbstractInterface
    02461 {
    02462     Q_OBJECT
    02463
    02464 public:
    02471     static inline const char *staticInterfaceName()
    02472     {
    02473         return "org.freedesktop.Telepathy.Channel.Interface.Password";
    02474     }
    02475
    02483     ChannelInterfacePasswordInterface(
    02484         const QString& busName,
    02485         const QString& objectPath,
    02486         QObject* parent = 0
    02487     );
    02488
    02497     ChannelInterfacePasswordInterface(
    02498         const QDBusConnection& connection,
    02499         const QString& busName,
    02500         const QString& objectPath,
    02501         QObject* parent = 0
    02502     );
    02503
    02510     ChannelInterfacePasswordInterface(Tp::DBusProxy *proxy);
    02511
    02519     explicit ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface);
    02520
    02528     ChannelInterfacePasswordInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02529
    02530 public Q_SLOTS:
    02543     inline QDBusPendingReply<uint> GetPasswordFlags()
    02544     {
    02545         if (!invalidationReason().isEmpty()) {
    02546             return QDBusPendingReply<uint>(QDBusMessage::createError(
    02547                 invalidationReason(),
    02548                 invalidationMessage()
    02549             ));
    02550         }
    02551
    02552
    02553         return asyncCall(QLatin1String("GetPasswordFlags"));
    02554     }
    02555
    02571     inline QDBusPendingReply<bool> ProvidePassword(const QString& password)
    02572     {
    02573         if (!invalidationReason().isEmpty()) {
    02574             return QDBusPendingReply<bool>(QDBusMessage::createError(
    02575                 invalidationReason(),
    02576                 invalidationMessage()
    02577             ));
    02578         }
    02579
    02580
    02581         QList<QVariant> argumentList;
    02582         argumentList << QVariant::fromValue(password);
    02583         return asyncCallWithArgumentList(QLatin1String("ProvidePassword"), argumentList);
    02584     }
    02585
    02586 Q_SIGNALS:
    02601     void PasswordFlagsChanged(uint added, uint removed);
    02602
    02603 protected:
    02604     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02605 };
    02606
    02614 class TELEPATHY_QT4_EXPORT ChannelInterfaceTubeInterface : public Tp::AbstractInterface
    02615 {
    02616     Q_OBJECT
    02617
    02618 public:
    02625     static inline const char *staticInterfaceName()
    02626     {
    02627         return "org.freedesktop.Telepathy.Channel.Interface.Tube";
    02628     }
    02629
    02637     ChannelInterfaceTubeInterface(
    02638         const QString& busName,
    02639         const QString& objectPath,
    02640         QObject* parent = 0
    02641     );
    02642
    02651     ChannelInterfaceTubeInterface(
    02652         const QDBusConnection& connection,
    02653         const QString& busName,
    02654         const QString& objectPath,
    02655         QObject* parent = 0
    02656     );
    02657
    02664     ChannelInterfaceTubeInterface(Tp::DBusProxy *proxy);
    02665
    02673     explicit ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    02674
    02682     ChannelInterfaceTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02683
    02723     Q_PROPERTY(QVariantMap Parameters READ Parameters)
    02724
    02725
    02733     inline QVariantMap Parameters() const TELEPATHY_GNUC_DEPRECATED
    02734     {
    02735         return qvariant_cast<QVariantMap>(internalPropGet("Parameters"));
    02736     }
    02737
    02747     Q_PROPERTY(uint State READ State)
    02748
    02749
    02757     inline uint State() const TELEPATHY_GNUC_DEPRECATED
    02758     {
    02759         return qvariant_cast<uint>(internalPropGet("State"));
    02760     }
    02761
    02762 Q_SIGNALS:
    02773     void TubeChannelStateChanged(uint state);
    02774
    02775 protected:
    02776     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02777 };
    02778
    02786 class TELEPATHY_QT4_EXPORT ChannelTypeContactListInterface : public Tp::AbstractInterface
    02787 {
    02788     Q_OBJECT
    02789
    02790 public:
    02797     static inline const char *staticInterfaceName()
    02798     {
    02799         return "org.freedesktop.Telepathy.Channel.Type.ContactList";
    02800     }
    02801
    02809     ChannelTypeContactListInterface(
    02810         const QString& busName,
    02811         const QString& objectPath,
    02812         QObject* parent = 0
    02813     );
    02814
    02823     ChannelTypeContactListInterface(
    02824         const QDBusConnection& connection,
    02825         const QString& busName,
    02826         const QString& objectPath,
    02827         QObject* parent = 0
    02828     );
    02829
    02836     ChannelTypeContactListInterface(Tp::DBusProxy *proxy);
    02837
    02845     explicit ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface);
    02846
    02854     ChannelTypeContactListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02855
    02856 protected:
    02857     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    02858 };
    02859
    02867 class TELEPATHY_QT4_EXPORT ChannelTypeFileTransferInterface : public Tp::AbstractInterface
    02868 {
    02869     Q_OBJECT
    02870
    02871 public:
    02878     static inline const char *staticInterfaceName()
    02879     {
    02880         return "org.freedesktop.Telepathy.Channel.Type.FileTransfer";
    02881     }
    02882
    02890     ChannelTypeFileTransferInterface(
    02891         const QString& busName,
    02892         const QString& objectPath,
    02893         QObject* parent = 0
    02894     );
    02895
    02904     ChannelTypeFileTransferInterface(
    02905         const QDBusConnection& connection,
    02906         const QString& busName,
    02907         const QString& objectPath,
    02908         QObject* parent = 0
    02909     );
    02910
    02917     ChannelTypeFileTransferInterface(Tp::DBusProxy *proxy);
    02918
    02926     explicit ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface);
    02927
    02935     ChannelTypeFileTransferInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    02936
    02943     Q_PROPERTY(uint State READ State)
    02944
    02945
    02953     inline uint State() const TELEPATHY_GNUC_DEPRECATED
    02954     {
    02955         return qvariant_cast<uint>(internalPropGet("State"));
    02956     }
    02957
    02969     Q_PROPERTY(QString ContentType READ ContentType)
    02970
    02971
    02979     inline QString ContentType() const TELEPATHY_GNUC_DEPRECATED
    02980     {
    02981         return qvariant_cast<QString>(internalPropGet("ContentType"));
    02982     }
    02983
    02999     Q_PROPERTY(QString Filename READ Filename)
    03000
    03001
    03009     inline QString Filename() const TELEPATHY_GNUC_DEPRECATED
    03010     {
    03011         return qvariant_cast<QString>(internalPropGet("Filename"));
    03012     }
    03013
    03031     Q_PROPERTY(qulonglong Size READ Size)
    03032
    03033
    03041     inline qulonglong Size() const TELEPATHY_GNUC_DEPRECATED
    03042     {
    03043         return qvariant_cast<qulonglong>(internalPropGet("Size"));
    03044     }
    03045
    03066     Q_PROPERTY(uint ContentHashType READ ContentHashType)
    03067
    03068
    03076     inline uint ContentHashType() const TELEPATHY_GNUC_DEPRECATED
    03077     {
    03078         return qvariant_cast<uint>(internalPropGet("ContentHashType"));
    03079     }
    03080
    03095     Q_PROPERTY(QString ContentHash READ ContentHash)
    03096
    03097
    03105     inline QString ContentHash() const TELEPATHY_GNUC_DEPRECATED
    03106     {
    03107         return qvariant_cast<QString>(internalPropGet("ContentHash"));
    03108     }
    03109
    03121     Q_PROPERTY(QString Description READ Description)
    03122
    03123
    03131     inline QString Description() const TELEPATHY_GNUC_DEPRECATED
    03132     {
    03133         return qvariant_cast<QString>(internalPropGet("Description"));
    03134     }
    03135
    03146     Q_PROPERTY(qlonglong Date READ Date)
    03147
    03148
    03156     inline qlonglong Date() const TELEPATHY_GNUC_DEPRECATED
    03157     {
    03158         return qvariant_cast<qlonglong>(internalPropGet("Date"));
    03159     }
    03160
    03183     Q_PROPERTY(Tp::SupportedSocketMap AvailableSocketTypes READ AvailableSocketTypes)
    03184
    03185
    03193     inline Tp::SupportedSocketMap AvailableSocketTypes() const TELEPATHY_GNUC_DEPRECATED
    03194     {
    03195         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("AvailableSocketTypes"));
    03196     }
    03197
    03205     Q_PROPERTY(qulonglong TransferredBytes READ TransferredBytes)
    03206
    03207
    03215     inline qulonglong TransferredBytes() const TELEPATHY_GNUC_DEPRECATED
    03216     {
    03217         return qvariant_cast<qulonglong>(internalPropGet("TransferredBytes"));
    03218     }
    03219
    03236     Q_PROPERTY(qulonglong InitialOffset READ InitialOffset)
    03237
    03238
    03246     inline qulonglong InitialOffset() const TELEPATHY_GNUC_DEPRECATED
    03247     {
    03248         return qvariant_cast<qulonglong>(internalPropGet("InitialOffset"));
    03249     }
    03250
    03251 public Q_SLOTS:
    03291     inline QDBusPendingReply<QDBusVariant> AcceptFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam, qulonglong offset)
    03292     {
    03293         if (!invalidationReason().isEmpty()) {
    03294             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    03295                 invalidationReason(),
    03296                 invalidationMessage()
    03297             ));
    03298         }
    03299
    03300
    03301         QList<QVariant> argumentList;
    03302         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam) << QVariant::fromValue(offset);
    03303         return asyncCallWithArgumentList(QLatin1String("AcceptFile"), argumentList);
    03304     }
    03305
    03334     inline QDBusPendingReply<QDBusVariant> ProvideFile(uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
    03335     {
    03336         if (!invalidationReason().isEmpty()) {
    03337             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    03338                 invalidationReason(),
    03339                 invalidationMessage()
    03340             ));
    03341         }
    03342
    03343
    03344         QList<QVariant> argumentList;
    03345         argumentList << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    03346         return asyncCallWithArgumentList(QLatin1String("ProvideFile"), argumentList);
    03347     }
    03348
    03349 Q_SIGNALS:
    03367     void FileTransferStateChanged(uint state, uint reason);
    03368
    03381     void TransferredBytesChanged(qulonglong count);
    03382
    03394     void InitialOffsetDefined(qulonglong initialOffset);
    03395
    03396 protected:
    03397     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03398 };
    03399
    03407 class TELEPATHY_QT4_EXPORT ChannelTypeRoomListInterface : public Tp::AbstractInterface
    03408 {
    03409     Q_OBJECT
    03410
    03411 public:
    03418     static inline const char *staticInterfaceName()
    03419     {
    03420         return "org.freedesktop.Telepathy.Channel.Type.RoomList";
    03421     }
    03422
    03430     ChannelTypeRoomListInterface(
    03431         const QString& busName,
    03432         const QString& objectPath,
    03433         QObject* parent = 0
    03434     );
    03435
    03444     ChannelTypeRoomListInterface(
    03445         const QDBusConnection& connection,
    03446         const QString& busName,
    03447         const QString& objectPath,
    03448         QObject* parent = 0
    03449     );
    03450
    03457     ChannelTypeRoomListInterface(Tp::DBusProxy *proxy);
    03458
    03466     explicit ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface);
    03467
    03475     ChannelTypeRoomListInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03476
    03486     Q_PROPERTY(QString Server READ Server)
    03487
    03488
    03496     inline QString Server() const TELEPATHY_GNUC_DEPRECATED
    03497     {
    03498         return qvariant_cast<QString>(internalPropGet("Server"));
    03499     }
    03500
    03501 public Q_SLOTS:
    03512     inline QDBusPendingReply<bool> GetListingRooms()
    03513     {
    03514         if (!invalidationReason().isEmpty()) {
    03515             return QDBusPendingReply<bool>(QDBusMessage::createError(
    03516                 invalidationReason(),
    03517                 invalidationMessage()
    03518             ));
    03519         }
    03520
    03521
    03522         return asyncCall(QLatin1String("GetListingRooms"));
    03523     }
    03524
    03533     inline QDBusPendingReply<> ListRooms()
    03534     {
    03535         if (!invalidationReason().isEmpty()) {
    03536             return QDBusPendingReply<>(QDBusMessage::createError(
    03537                 invalidationReason(),
    03538                 invalidationMessage()
    03539             ));
    03540         }
    03541
    03542
    03543         return asyncCall(QLatin1String("ListRooms"));
    03544     }
    03545
    03553     inline QDBusPendingReply<> StopListing()
    03554     {
    03555         if (!invalidationReason().isEmpty()) {
    03556             return QDBusPendingReply<>(QDBusMessage::createError(
    03557                 invalidationReason(),
    03558                 invalidationMessage()
    03559             ));
    03560         }
    03561
    03562
    03563         return asyncCall(QLatin1String("StopListing"));
    03564     }
    03565
    03566 Q_SIGNALS:
    03611     void GotRooms(const Tp::RoomInfoList& rooms);
    03612
    03623     void ListingRooms(bool listing);
    03624
    03625 protected:
    03626     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03627 };
    03628
    03636 class TELEPATHY_QT4_EXPORT ChannelTypeStreamTubeInterface : public Tp::AbstractInterface
    03637 {
    03638     Q_OBJECT
    03639
    03640 public:
    03647     static inline const char *staticInterfaceName()
    03648     {
    03649         return "org.freedesktop.Telepathy.Channel.Type.StreamTube";
    03650     }
    03651
    03659     ChannelTypeStreamTubeInterface(
    03660         const QString& busName,
    03661         const QString& objectPath,
    03662         QObject* parent = 0
    03663     );
    03664
    03673     ChannelTypeStreamTubeInterface(
    03674         const QDBusConnection& connection,
    03675         const QString& busName,
    03676         const QString& objectPath,
    03677         QObject* parent = 0
    03678     );
    03679
    03686     ChannelTypeStreamTubeInterface(Tp::DBusProxy *proxy);
    03687
    03695     explicit ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface);
    03696
    03704     ChannelTypeStreamTubeInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    03705
    03722     Q_PROPERTY(QString Service READ Service)
    03723
    03724
    03732     inline QString Service() const TELEPATHY_GNUC_DEPRECATED
    03733     {
    03734         return qvariant_cast<QString>(internalPropGet("Service"));
    03735     }
    03736
    03765     Q_PROPERTY(Tp::SupportedSocketMap SupportedSocketTypes READ SupportedSocketTypes)
    03766
    03767
    03775     inline Tp::SupportedSocketMap SupportedSocketTypes() const TELEPATHY_GNUC_DEPRECATED
    03776     {
    03777         return qvariant_cast<Tp::SupportedSocketMap>(internalPropGet("SupportedSocketTypes"));
    03778     }
    03779
    03780 public Q_SLOTS:
    03806     inline QDBusPendingReply<> Offer(uint addresstype, const QDBusVariant& address, uint accesscontrol, const QVariantMap& parameters)
    03807     {
    03808         if (!invalidationReason().isEmpty()) {
    03809             return QDBusPendingReply<>(QDBusMessage::createError(
    03810                 invalidationReason(),
    03811                 invalidationMessage()
    03812             ));
    03813         }
    03814
    03815
    03816         QList<QVariant> argumentList;
    03817         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(address) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(parameters);
    03818         return asyncCallWithArgumentList(QLatin1String("Offer"), argumentList);
    03819     }
    03820
    03854     inline QDBusPendingReply<QDBusVariant> Accept(uint addresstype, uint accesscontrol, const QDBusVariant& accesscontrolparam)
    03855     {
    03856         if (!invalidationReason().isEmpty()) {
    03857             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    03858                 invalidationReason(),
    03859                 invalidationMessage()
    03860             ));
    03861         }
    03862
    03863
    03864         QList<QVariant> argumentList;
    03865         argumentList << QVariant::fromValue(addresstype) << QVariant::fromValue(accesscontrol) << QVariant::fromValue(accesscontrolparam);
    03866         return asyncCallWithArgumentList(QLatin1String("Accept"), argumentList);
    03867     }
    03868
    03869 Q_SIGNALS:
    03906     void NewRemoteConnection(uint handle, const QDBusVariant& connectionParam, uint connectionID);
    03907
    03921     void NewLocalConnection(uint connectionID);
    03922
    03950     void ConnectionClosed(uint connectionID, const QString& error, const QString& message);
    03951
    03952 protected:
    03953     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    03954 };
    03955
    03963 class TELEPATHY_QT4_EXPORT ChannelTypeStreamedMediaInterface : public Tp::AbstractInterface
    03964 {
    03965     Q_OBJECT
    03966
    03967 public:
    03974     static inline const char *staticInterfaceName()
    03975     {
    03976         return "org.freedesktop.Telepathy.Channel.Type.StreamedMedia";
    03977     }
    03978
    03986     ChannelTypeStreamedMediaInterface(
    03987         const QString& busName,
    03988         const QString& objectPath,
    03989         QObject* parent = 0
    03990     );
    03991
    04000     ChannelTypeStreamedMediaInterface(
    04001         const QDBusConnection& connection,
    04002         const QString& busName,
    04003         const QString& objectPath,
    04004         QObject* parent = 0
    04005     );
    04006
    04013     ChannelTypeStreamedMediaInterface(Tp::DBusProxy *proxy);
    04014
    04022     explicit ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface);
    04023
    04031     ChannelTypeStreamedMediaInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04032
    04115     Q_PROPERTY(bool InitialAudio READ InitialAudio)
    04116
    04117
    04125     inline bool InitialAudio() const TELEPATHY_GNUC_DEPRECATED
    04126     {
    04127         return qvariant_cast<bool>(internalPropGet("InitialAudio"));
    04128     }
    04129
    04144     Q_PROPERTY(bool InitialVideo READ InitialVideo)
    04145
    04146
    04154     inline bool InitialVideo() const TELEPATHY_GNUC_DEPRECATED
    04155     {
    04156         return qvariant_cast<bool>(internalPropGet("InitialVideo"));
    04157     }
    04158
    04195     Q_PROPERTY(bool ImmutableStreams READ ImmutableStreams)
    04196
    04197
    04205     inline bool ImmutableStreams() const TELEPATHY_GNUC_DEPRECATED
    04206     {
    04207         return qvariant_cast<bool>(internalPropGet("ImmutableStreams"));
    04208     }
    04209
    04210 public Q_SLOTS:
    04231     inline QDBusPendingReply<Tp::MediaStreamInfoList> ListStreams()
    04232     {
    04233         if (!invalidationReason().isEmpty()) {
    04234             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    04235                 invalidationReason(),
    04236                 invalidationMessage()
    04237             ));
    04238         }
    04239
    04240
    04241         return asyncCall(QLatin1String("ListStreams"));
    04242     }
    04243
    04263     inline QDBusPendingReply<> RemoveStreams(const Tp::UIntList& streams)
    04264     {
    04265         if (!invalidationReason().isEmpty()) {
    04266             return QDBusPendingReply<>(QDBusMessage::createError(
    04267                 invalidationReason(),
    04268                 invalidationMessage()
    04269             ));
    04270         }
    04271
    04272
    04273         QList<QVariant> argumentList;
    04274         argumentList << QVariant::fromValue(streams);
    04275         return asyncCallWithArgumentList(QLatin1String("RemoveStreams"), argumentList);
    04276     }
    04277
    04307     inline QDBusPendingReply<> RequestStreamDirection(uint streamID, uint streamDirection)
    04308     {
    04309         if (!invalidationReason().isEmpty()) {
    04310             return QDBusPendingReply<>(QDBusMessage::createError(
    04311                 invalidationReason(),
    04312                 invalidationMessage()
    04313             ));
    04314         }
    04315
    04316
    04317         QList<QVariant> argumentList;
    04318         argumentList << QVariant::fromValue(streamID) << QVariant::fromValue(streamDirection);
    04319         return asyncCallWithArgumentList(QLatin1String("RequestStreamDirection"), argumentList);
    04320     }
    04321
    04365     inline QDBusPendingReply<Tp::MediaStreamInfoList> RequestStreams(uint contactHandle, const Tp::UIntList& types)
    04366     {
    04367         if (!invalidationReason().isEmpty()) {
    04368             return QDBusPendingReply<Tp::MediaStreamInfoList>(QDBusMessage::createError(
    04369                 invalidationReason(),
    04370                 invalidationMessage()
    04371             ));
    04372         }
    04373
    04374
    04375         QList<QVariant> argumentList;
    04376         argumentList << QVariant::fromValue(contactHandle) << QVariant::fromValue(types);
    04377         return asyncCallWithArgumentList(QLatin1String("RequestStreams"), argumentList);
    04378     }
    04379
    04380 Q_SIGNALS:
    04445     void StreamAdded(uint streamID, uint contactHandle, uint streamType);
    04446
    04476     void StreamDirectionChanged(uint streamID, uint streamDirection, uint pendingFlags);
    04477
    04495     void StreamError(uint streamID, uint errorCode, const QString& message);
    04496
    04506     void StreamRemoved(uint streamID);
    04507
    04521     void StreamStateChanged(uint streamID, uint streamState);
    04522
    04523 protected:
    04524     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04525 };
    04526
    04534 class TELEPATHY_QT4_EXPORT ChannelTypeTextInterface : public Tp::AbstractInterface
    04535 {
    04536     Q_OBJECT
    04537
    04538 public:
    04545     static inline const char *staticInterfaceName()
    04546     {
    04547         return "org.freedesktop.Telepathy.Channel.Type.Text";
    04548     }
    04549
    04557     ChannelTypeTextInterface(
    04558         const QString& busName,
    04559         const QString& objectPath,
    04560         QObject* parent = 0
    04561     );
    04562
    04571     ChannelTypeTextInterface(
    04572         const QDBusConnection& connection,
    04573         const QString& busName,
    04574         const QString& objectPath,
    04575         QObject* parent = 0
    04576     );
    04577
    04584     ChannelTypeTextInterface(Tp::DBusProxy *proxy);
    04585
    04593     explicit ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface);
    04594
    04602     ChannelTypeTextInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04603
    04604 public Q_SLOTS:
    04615     inline QDBusPendingReply<> AcknowledgePendingMessages(const Tp::UIntList& IDs)
    04616     {
    04617         if (!invalidationReason().isEmpty()) {
    04618             return QDBusPendingReply<>(QDBusMessage::createError(
    04619                 invalidationReason(),
    04620                 invalidationMessage()
    04621             ));
    04622         }
    04623
    04624
    04625         QList<QVariant> argumentList;
    04626         argumentList << QVariant::fromValue(IDs);
    04627         return asyncCallWithArgumentList(QLatin1String("AcknowledgePendingMessages"), argumentList);
    04628     }
    04629
    04640     inline QDBusPendingReply<Tp::UIntList> GetMessageTypes()
    04641     {
    04642         if (!invalidationReason().isEmpty()) {
    04643             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    04644                 invalidationReason(),
    04645                 invalidationMessage()
    04646             ));
    04647         }
    04648
    04649
    04650         return asyncCall(QLatin1String("GetMessageTypes"));
    04651     }
    04652
    04676     inline QDBusPendingReply<Tp::PendingTextMessageList> ListPendingMessages(bool clear)
    04677     {
    04678         if (!invalidationReason().isEmpty()) {
    04679             return QDBusPendingReply<Tp::PendingTextMessageList>(QDBusMessage::createError(
    04680                 invalidationReason(),
    04681                 invalidationMessage()
    04682             ));
    04683         }
    04684
    04685
    04686         QList<QVariant> argumentList;
    04687         argumentList << QVariant::fromValue(clear);
    04688         return asyncCallWithArgumentList(QLatin1String("ListPendingMessages"), argumentList);
    04689     }
    04690
    04716     inline QDBusPendingReply<> Send(uint type, const QString& text)
    04717     {
    04718         if (!invalidationReason().isEmpty()) {
    04719             return QDBusPendingReply<>(QDBusMessage::createError(
    04720                 invalidationReason(),
    04721                 invalidationMessage()
    04722             ));
    04723         }
    04724
    04725
    04726         QList<QVariant> argumentList;
    04727         argumentList << QVariant::fromValue(type) << QVariant::fromValue(text);
    04728         return asyncCallWithArgumentList(QLatin1String("Send"), argumentList);
    04729     }
    04730
    04731 Q_SIGNALS:
    04739     void LostMessage();
    04740
    04774     void Received(uint ID, uint timestamp, uint sender, uint type, uint flags, const QString& text);
    04775
    04802     void SendError(uint error, uint timestamp, uint type, const QString& text);
    04803
    04825     void Sent(uint timestamp, uint type, const QString& text);
    04826
    04827 protected:
    04828     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    04829 };
    04830
    04838 class TELEPATHY_QT4_EXPORT ChannelTypeTubesInterface : public Tp::AbstractInterface
    04839 {
    04840     Q_OBJECT
    04841
    04842 public:
    04849     static inline const char *staticInterfaceName()
    04850     {
    04851         return "org.freedesktop.Telepathy.Channel.Type.Tubes";
    04852     }
    04853
    04861     ChannelTypeTubesInterface(
    04862         const QString& busName,
    04863         const QString& objectPath,
    04864         QObject* parent = 0
    04865     );
    04866
    04875     ChannelTypeTubesInterface(
    04876         const QDBusConnection& connection,
    04877         const QString& busName,
    04878         const QString& objectPath,
    04879         QObject* parent = 0
    04880     );
    04881
    04888     ChannelTypeTubesInterface(Tp::DBusProxy *proxy);
    04889
    04897     explicit ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface);
    04898
    04906     ChannelTypeTubesInterface(const Tp::Client::ChannelInterface& mainInterface, QObject* parent);
    04907
    04908 public Q_SLOTS:
    04938     inline QDBusPendingReply<Tp::SupportedSocketMap> GetAvailableStreamTubeTypes()
    04939     {
    04940         if (!invalidationReason().isEmpty()) {
    04941             return QDBusPendingReply<Tp::SupportedSocketMap>(QDBusMessage::createError(
    04942                 invalidationReason(),
    04943                 invalidationMessage()
    04944             ));
    04945         }
    04946
    04947
    04948         return asyncCall(QLatin1String("GetAvailableStreamTubeTypes"));
    04949     }
    04950
    04959     inline QDBusPendingReply<Tp::UIntList> GetAvailableTubeTypes()
    04960     {
    04961         if (!invalidationReason().isEmpty()) {
    04962             return QDBusPendingReply<Tp::UIntList>(QDBusMessage::createError(
    04963                 invalidationReason(),
    04964                 invalidationMessage()
    04965             ));
    04966         }
    04967
    04968
    04969         return asyncCall(QLatin1String("GetAvailableTubeTypes"));
    04970     }
    04971
    04982     inline QDBusPendingReply<Tp::TubeInfoList> ListTubes()
    04983     {
    04984         if (!invalidationReason().isEmpty()) {
    04985             return QDBusPendingReply<Tp::TubeInfoList>(QDBusMessage::createError(
    04986                 invalidationReason(),
    04987                 invalidationMessage()
    04988             ));
    04989         }
    04990
    04991
    04992         return asyncCall(QLatin1String("ListTubes"));
    04993     }
    04994
    05017     inline QDBusPendingReply<uint> OfferDBusTube(const QString& service, const QVariantMap& parameters)
    05018     {
    05019         if (!invalidationReason().isEmpty()) {
    05020             return QDBusPendingReply<uint>(QDBusMessage::createError(
    05021                 invalidationReason(),
    05022                 invalidationMessage()
    05023             ));
    05024         }
    05025
    05026
    05027         QList<QVariant> argumentList;
    05028         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters);
    05029         return asyncCallWithArgumentList(QLatin1String("OfferDBusTube"), argumentList);
    05030     }
    05031
    05082     inline QDBusPendingReply<uint> OfferStreamTube(const QString& service, const QVariantMap& parameters, uint addressType, const QDBusVariant& address, uint accessControl, const QDBusVariant& accessControlParam)
    05083     {
    05084         if (!invalidationReason().isEmpty()) {
    05085             return QDBusPendingReply<uint>(QDBusMessage::createError(
    05086                 invalidationReason(),
    05087                 invalidationMessage()
    05088             ));
    05089         }
    05090
    05091
    05092         QList<QVariant> argumentList;
    05093         argumentList << QVariant::fromValue(service) << QVariant::fromValue(parameters) << QVariant::fromValue(addressType) << QVariant::fromValue(address) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    05094         return asyncCallWithArgumentList(QLatin1String("OfferStreamTube"), argumentList);
    05095     }
    05096
    05114     inline QDBusPendingReply<QString> AcceptDBusTube(uint ID)
    05115     {
    05116         if (!invalidationReason().isEmpty()) {
    05117             return QDBusPendingReply<QString>(QDBusMessage::createError(
    05118                 invalidationReason(),
    05119                 invalidationMessage()
    05120             ));
    05121         }
    05122
    05123
    05124         QList<QVariant> argumentList;
    05125         argumentList << QVariant::fromValue(ID);
    05126         return asyncCallWithArgumentList(QLatin1String("AcceptDBusTube"), argumentList);
    05127     }
    05128
    05161     inline QDBusPendingReply<QDBusVariant> AcceptStreamTube(uint ID, uint addressType, uint accessControl, const QDBusVariant& accessControlParam)
    05162     {
    05163         if (!invalidationReason().isEmpty()) {
    05164             return QDBusPendingReply<QDBusVariant>(QDBusMessage::createError(
    05165                 invalidationReason(),
    05166                 invalidationMessage()
    05167             ));
    05168         }
    05169
    05170
    05171         QList<QVariant> argumentList;
    05172         argumentList << QVariant::fromValue(ID) << QVariant::fromValue(addressType) << QVariant::fromValue(accessControl) << QVariant::fromValue(accessControlParam);
    05173         return asyncCallWithArgumentList(QLatin1String("AcceptStreamTube"), argumentList);
    05174     }
    05175
    05185     inline QDBusPendingReply<> CloseTube(uint ID)
    05186     {
    05187         if (!invalidationReason().isEmpty()) {
    05188             return QDBusPendingReply<>(QDBusMessage::createError(
    05189                 invalidationReason(),
    05190                 invalidationMessage()
    05191             ));
    05192         }
    05193
    05194
    05195         QList<QVariant> argumentList;
    05196         argumentList << QVariant::fromValue(ID);
    05197         return asyncCallWithArgumentList(QLatin1String("CloseTube"), argumentList);
    05198     }
    05199
    05214     inline QDBusPendingReply<QString> GetDBusTubeAddress(uint ID)
    05215     {
    05216         if (!invalidationReason().isEmpty()) {
    05217             return QDBusPendingReply<QString>(QDBusMessage::createError(
    05218                 invalidationReason(),
    05219                 invalidationMessage()
    05220             ));
    05221         }
    05222
    05223
    05224         QList<QVariant> argumentList;
    05225         argumentList << QVariant::fromValue(ID);
    05226         return asyncCallWithArgumentList(QLatin1String("GetDBusTubeAddress"), argumentList);
    05227     }
    05228
    05244     inline QDBusPendingReply<Tp::DBusTubeMemberList> GetDBusNames(uint ID)
    05245     {
    05246         if (!invalidationReason().isEmpty()) {
    05247             return QDBusPendingReply<Tp::DBusTubeMemberList>(QDBusMessage::createError(
    05248                 invalidationReason(),
    05249                 invalidationMessage()
    05250             ));
    05251         }
    05252
    05253
    05254         QList<QVariant> argumentList;
    05255         argumentList << QVariant::fromValue(ID);
    05256         return asyncCallWithArgumentList(QLatin1String("GetDBusNames"), argumentList);
    05257     }
    05258
    05279     inline QDBusPendingReply<uint, QDBusVariant> GetStreamTubeSocketAddress(uint ID)
    05280     {
    05281         if (!invalidationReason().isEmpty()) {
    05282             return QDBusPendingReply<uint, QDBusVariant>(QDBusMessage::createError(
    05283                 invalidationReason(),
    05284                 invalidationMessage()
    05285             ));
    05286         }
    05287
    05288
    05289         QList<QVariant> argumentList;
    05290         argumentList << QVariant::fromValue(ID);
    05291         return asyncCallWithArgumentList(QLatin1String("GetStreamTubeSocketAddress"), argumentList);
    05292     }
    05293
    05294 Q_SIGNALS:
    05324     void NewTube(uint ID, uint initiator, uint type, const QString& service, const QVariantMap& parameters, uint state);
    05325
    05339     void TubeStateChanged(uint ID, uint state);
    05340
    05351     void TubeClosed(uint ID);
    05352
    05371     void DBusNamesChanged(uint ID, const Tp::DBusTubeMemberList& added, const Tp::UIntList& removed);
    05372
    05387     void StreamTubeNewConnection(uint ID, uint handle);
    05388
    05389 protected:
    05390     virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
    05391 };
    05392 }
    05393 }
    05394 Q_DECLARE_METATYPE(Tp::Client::ChannelInterface*)
    05395 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceCallStateInterface*)
    05396 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceChatStateInterface*)
    05397 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceDTMFInterface*)
    05398 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceGroupInterface*)
    05399 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceHoldInterface*)
    05400 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMediaSignallingInterface*)
    05401 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceMessagesInterface*)
    05402 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfacePasswordInterface*)
    05403 Q_DECLARE_METATYPE(Tp::Client::ChannelInterfaceTubeInterface*)
    05404 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeContactListInterface*)
    05405 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeFileTransferInterface*)
    05406 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeRoomListInterface*)
    05407 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamTubeInterface*)
    05408 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeStreamedMediaInterface*)
    05409 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTextInterface*)
    05410 Q_DECLARE_METATYPE(Tp::Client::ChannelTypeTubesInterface*)