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

cli-client.h

/*
 * This file contains D-Bus client proxy classes generated by qt4-client-gen.py.
 *
 * This file can be distributed under the same terms as the specification from
 * which it was generated.
 */

#ifndef IN_TELEPATHY_QT4_HEADER
#error IN_TELEPATHY_QT4_HEADER
#endif

#include <TelepathyQt4/Types>

#include <QtGlobal>

#include <QString>
#include <QObject>
#include <QVariant>

#include <QDBusPendingReply>

#include <TelepathyQt4/AbstractInterface>
#include <TelepathyQt4/DBusProxy>
#include <TelepathyQt4/Global>

// basically the same as GLib's G_GNUC_DEPRECATED
#ifndef TELEPATHY_GNUC_DEPRECATED
#   if defined(Q_CC_GNUC) && __GNUC__ >= 4
#       define TELEPATHY_GNUC_DEPRECATED __attribute__((__deprecated__))
#   else
#       define TELEPATHY_GNUC_DEPRECATED
#   endif
#endif
namespace Tp
{
namespace Client
{

class TELEPATHY_QT4_EXPORT ClientInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Client";
    }

    ClientInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientInterface(Tp::DBusProxy *proxy);

    Q_PROPERTY(QStringList Interfaces READ Interfaces)

    
    inline QStringList Interfaces() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QStringList>(internalPropGet("Interfaces"));
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT ClientApproverInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Client.Approver";
    }

    ClientApproverInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientApproverInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientApproverInterface(Tp::DBusProxy *proxy);

    explicit ClientApproverInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientApproverInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::ChannelClassList ApproverChannelFilter READ ApproverChannelFilter)

    
    inline Tp::ChannelClassList ApproverChannelFilter() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<Tp::ChannelClassList>(internalPropGet("ApproverChannelFilter"));
    }

public Q_SLOTS:
    inline QDBusPendingReply<> AddDispatchOperation(const Tp::ChannelDetailsList& channels, const QDBusObjectPath& dispatchOperation, const QVariantMap& properties)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(channels) << QVariant::fromValue(dispatchOperation) << QVariant::fromValue(properties);
        return asyncCallWithArgumentList(QLatin1String("AddDispatchOperation"), argumentList);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT ClientHandlerInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Client.Handler";
    }

    ClientHandlerInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientHandlerInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientHandlerInterface(Tp::DBusProxy *proxy);

    explicit ClientHandlerInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientHandlerInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::ChannelClassList HandlerChannelFilter READ HandlerChannelFilter)

    
    inline Tp::ChannelClassList HandlerChannelFilter() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<Tp::ChannelClassList>(internalPropGet("HandlerChannelFilter"));
    }

    Q_PROPERTY(bool BypassApproval READ BypassApproval)

    
    inline bool BypassApproval() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<bool>(internalPropGet("BypassApproval"));
    }

    Q_PROPERTY(QStringList Capabilities READ Capabilities)

    
    inline QStringList Capabilities() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<QStringList>(internalPropGet("Capabilities"));
    }

    Q_PROPERTY(Tp::ObjectPathList HandledChannels READ HandledChannels)

    
    inline Tp::ObjectPathList HandledChannels() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<Tp::ObjectPathList>(internalPropGet("HandledChannels"));
    }

public Q_SLOTS:
    inline QDBusPendingReply<> HandleChannels(const QDBusObjectPath& account, const QDBusObjectPath& connection, const Tp::ChannelDetailsList& channels, const Tp::ObjectPathList& requestsSatisfied, qulonglong userActionTime, const QVariantMap& handlerInfo)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(account) << QVariant::fromValue(connection) << QVariant::fromValue(channels) << QVariant::fromValue(requestsSatisfied) << QVariant::fromValue(userActionTime) << QVariant::fromValue(handlerInfo);
        return asyncCallWithArgumentList(QLatin1String("HandleChannels"), argumentList);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT ClientInterfaceRequestsInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Client.Interface.Requests";
    }

    ClientInterfaceRequestsInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientInterfaceRequestsInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientInterfaceRequestsInterface(Tp::DBusProxy *proxy);

    explicit ClientInterfaceRequestsInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientInterfaceRequestsInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

public Q_SLOTS:
    inline QDBusPendingReply<> AddRequest(const QDBusObjectPath& request, const QVariantMap& properties)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(request) << QVariant::fromValue(properties);
        return asyncCallWithArgumentList(QLatin1String("AddRequest"), argumentList);
    }

    inline QDBusPendingReply<> RemoveRequest(const QDBusObjectPath& request, const QString& error, const QString& message)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(request) << QVariant::fromValue(error) << QVariant::fromValue(message);
        return asyncCallWithArgumentList(QLatin1String("RemoveRequest"), argumentList);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};

class TELEPATHY_QT4_EXPORT ClientObserverInterface : public Tp::AbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    {
        return "org.freedesktop.Telepathy.Client.Observer";
    }

    ClientObserverInterface(
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientObserverInterface(
        const QDBusConnection& connection,
        const QString& busName,
        const QString& objectPath,
        QObject* parent = 0
    );

    ClientObserverInterface(Tp::DBusProxy *proxy);

    explicit ClientObserverInterface(const Tp::Client::ClientInterface& mainInterface);

    ClientObserverInterface(const Tp::Client::ClientInterface& mainInterface, QObject* parent);

    Q_PROPERTY(Tp::ChannelClassList ObserverChannelFilter READ ObserverChannelFilter)

    
    inline Tp::ChannelClassList ObserverChannelFilter() const TELEPATHY_GNUC_DEPRECATED
    {
        return qvariant_cast<Tp::ChannelClassList>(internalPropGet("ObserverChannelFilter"));
    }

public Q_SLOTS:
    inline QDBusPendingReply<> ObserveChannels(const QDBusObjectPath& account, const QDBusObjectPath& connection, const Tp::ChannelDetailsList& channels, const QDBusObjectPath& dispatchOperation, const Tp::ObjectPathList& requestsSatisfied, const QVariantMap& observerInfo)
    {
        if (!invalidationReason().isEmpty()) {
            return QDBusPendingReply<>(QDBusMessage::createError(
                invalidationReason(),
                invalidationMessage()
            ));
        }


        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(account) << QVariant::fromValue(connection) << QVariant::fromValue(channels) << QVariant::fromValue(dispatchOperation) << QVariant::fromValue(requestsSatisfied) << QVariant::fromValue(observerInfo);
        return asyncCallWithArgumentList(QLatin1String("ObserveChannels"), argumentList);
    }

protected:
    virtual void invalidate(Tp::DBusProxy *, const QString &, const QString &);
};
}
}