/*
 * This file was generated by qdbusxml2cpp-fix version 0.8
 * Command line was: qdbusxml2cpp-fix -c DeepinWm -p /build/deepin-session/src/dde-session/dbusinterface/com_deepin_Wm /build/deepin-session/src/dde-session/dbus/interface/com.deepin.wm.xml
 *
 * qdbusxml2cpp-fix is Copyright (C) 2016 Deepin Technology Co., Ltd.
 *
 * This is an auto-generated file.
 * Do not edit! All changes made to it will be lost.
 */

#ifndef COM_DEEPIN_WM_H
#define COM_DEEPIN_WM_H

#include <QtCore/QObject>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>

#include <DDBusExtendedAbstractInterface>
#include <QtDBus/QtDBus>


/*
 * Proxy class for interface com.deepin.wm
 */
class __DeepinWmPrivate;
class __DeepinWm : public DTK_CORE_NAMESPACE::DDBusExtendedAbstractInterface
{
    Q_OBJECT

public:
    static inline const char *staticInterfaceName()
    { return "com.deepin.wm"; }

public:
    explicit __DeepinWm(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = 0);

    ~__DeepinWm();

    Q_PROPERTY(bool compositingAllowSwitch READ compositingAllowSwitch NOTIFY CompositingAllowSwitchChanged)
    bool compositingAllowSwitch();

    Q_PROPERTY(bool compositingEnabled READ compositingEnabled WRITE setCompositingEnabled NOTIFY CompositingEnabledChanged)
    bool compositingEnabled();
    void setCompositingEnabled(bool value);

    Q_PROPERTY(bool compositingPossible READ compositingPossible NOTIFY CompositingPossibleChanged)
    bool compositingPossible();

    Q_PROPERTY(int cursorSize READ cursorSize WRITE setCursorSize NOTIFY CursorSizeChanged)
    int cursorSize();
    void setCursorSize(int value);

    Q_PROPERTY(QString cursorTheme READ cursorTheme WRITE setCursorTheme NOTIFY CursorThemeChanged)
    QString cursorTheme();
    void setCursorTheme(const QString &value);

    Q_PROPERTY(bool zoneEnabled READ zoneEnabled WRITE setZoneEnabled NOTIFY ZoneEnabledChanged)
    bool zoneEnabled();
    void setZoneEnabled(bool value);

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> BeginToMoveActiveWindow()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("BeginToMoveActiveWindow"), argumentList);
    }

    inline void BeginToMoveActiveWindowQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("BeginToMoveActiveWindow"), argumentList);
    }


    inline QDBusPendingReply<> CancelPreviewWindow()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("CancelPreviewWindow"), argumentList);
    }

    inline void CancelPreviewWindowQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("CancelPreviewWindow"), argumentList);
    }


    inline QDBusPendingReply<> ChangeCurrentWorkspaceBackground(const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri);
        return asyncCallWithArgumentList(QStringLiteral("ChangeCurrentWorkspaceBackground"), argumentList);
    }

    inline void ChangeCurrentWorkspaceBackgroundQueued(const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri);

        CallQueued(QStringLiteral("ChangeCurrentWorkspaceBackground"), argumentList);
    }


    inline QDBusPendingReply<> ClearMoveStatus()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ClearMoveStatus"), argumentList);
    }

    inline void ClearMoveStatusQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("ClearMoveStatus"), argumentList);
    }


    inline QDBusPendingReply<> EnableZoneDetected(bool enabled)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(enabled);
        return asyncCallWithArgumentList(QStringLiteral("EnableZoneDetected"), argumentList);
    }

    inline void EnableZoneDetectedQueued(bool enabled)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(enabled);

        CallQueued(QStringLiteral("EnableZoneDetected"), argumentList);
    }


    inline QDBusPendingReply<QStringList> GetAccel(const QString &id)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(id);
        return asyncCallWithArgumentList(QStringLiteral("GetAccel"), argumentList);
    }



    inline QDBusPendingReply<QString> GetAllAccels()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetAllAccels"), argumentList);
    }



    inline QDBusPendingReply<int> GetCurrentWorkspace()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetCurrentWorkspace"), argumentList);
    }



    inline QDBusPendingReply<QString> GetCurrentWorkspaceBackground()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetCurrentWorkspaceBackground"), argumentList);
    }



    inline QDBusPendingReply<QString> GetCurrentWorkspaceBackgroundForMonitor(const QString &strMonitorName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(strMonitorName);
        return asyncCallWithArgumentList(QStringLiteral("GetCurrentWorkspaceBackgroundForMonitor"), argumentList);
    }



    inline QDBusPendingReply<QStringList> GetDefaultAccel(const QString &id)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(id);
        return asyncCallWithArgumentList(QStringLiteral("GetDefaultAccel"), argumentList);
    }



    inline QDBusPendingReply<bool> GetIsShowDesktop()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetIsShowDesktop"), argumentList);
    }



    inline QDBusPendingReply<bool> GetMultiTaskingStatus()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetMultiTaskingStatus"), argumentList);
    }



    inline QDBusPendingReply<QString> GetWorkspaceBackground(int index)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index);
        return asyncCallWithArgumentList(QStringLiteral("GetWorkspaceBackground"), argumentList);
    }



    inline QDBusPendingReply<QString> GetWorkspaceBackgroundForMonitor(int index, const QString &strMonitorName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index) << QVariant::fromValue(strMonitorName);
        return asyncCallWithArgumentList(QStringLiteral("GetWorkspaceBackgroundForMonitor"), argumentList);
    }



    inline QDBusPendingReply<> MinimizeActiveWindow()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("MinimizeActiveWindow"), argumentList);
    }

    inline void MinimizeActiveWindowQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("MinimizeActiveWindow"), argumentList);
    }


    inline QDBusPendingReply<> NextWorkspace()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("NextWorkspace"), argumentList);
    }

    inline void NextWorkspaceQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("NextWorkspace"), argumentList);
    }


    inline QDBusPendingReply<> PerformAction(int type)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type);
        return asyncCallWithArgumentList(QStringLiteral("PerformAction"), argumentList);
    }

    inline void PerformActionQueued(int type)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type);

        CallQueued(QStringLiteral("PerformAction"), argumentList);
    }


    inline QDBusPendingReply<> PresentWindows(const QList<uint> &xids)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(xids);
        return asyncCallWithArgumentList(QStringLiteral("PresentWindows"), argumentList);
    }

    inline void PresentWindowsQueued(const QList<uint> &xids)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(xids);

        CallQueued(QStringLiteral("PresentWindows"), argumentList);
    }


    inline QDBusPendingReply<> PreviewWindow(uint xid)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(xid);
        return asyncCallWithArgumentList(QStringLiteral("PreviewWindow"), argumentList);
    }

    inline void PreviewWindowQueued(uint xid)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(xid);

        CallQueued(QStringLiteral("PreviewWindow"), argumentList);
    }


    inline QDBusPendingReply<> PreviousWorkspace()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("PreviousWorkspace"), argumentList);
    }

    inline void PreviousWorkspaceQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("PreviousWorkspace"), argumentList);
    }


    inline QDBusPendingReply<> RemoveAccel(const QString &id)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(id);
        return asyncCallWithArgumentList(QStringLiteral("RemoveAccel"), argumentList);
    }

    inline void RemoveAccelQueued(const QString &id)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(id);

        CallQueued(QStringLiteral("RemoveAccel"), argumentList);
    }


    inline QDBusPendingReply<bool> SetAccel(const QString &data)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(data);
        return asyncCallWithArgumentList(QStringLiteral("SetAccel"), argumentList);
    }



    inline QDBusPendingReply<> SetCurrentWorkspace(int index)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index);
        return asyncCallWithArgumentList(QStringLiteral("SetCurrentWorkspace"), argumentList);
    }

    inline void SetCurrentWorkspaceQueued(int index)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index);

        CallQueued(QStringLiteral("SetCurrentWorkspace"), argumentList);
    }


    inline QDBusPendingReply<> SetCurrentWorkspaceBackground(const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri);
        return asyncCallWithArgumentList(QStringLiteral("SetCurrentWorkspaceBackground"), argumentList);
    }

    inline void SetCurrentWorkspaceBackgroundQueued(const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri);

        CallQueued(QStringLiteral("SetCurrentWorkspaceBackground"), argumentList);
    }


    inline QDBusPendingReply<> SetCurrentWorkspaceBackgroundForMonitor(const QString &uri, const QString &strMonitorName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri) << QVariant::fromValue(strMonitorName);
        return asyncCallWithArgumentList(QStringLiteral("SetCurrentWorkspaceBackgroundForMonitor"), argumentList);
    }

    inline void SetCurrentWorkspaceBackgroundForMonitorQueued(const QString &uri, const QString &strMonitorName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri) << QVariant::fromValue(strMonitorName);

        CallQueued(QStringLiteral("SetCurrentWorkspaceBackgroundForMonitor"), argumentList);
    }


    inline QDBusPendingReply<> SetDecorationDeepinTheme(const QString &deepinThemeName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(deepinThemeName);
        return asyncCallWithArgumentList(QStringLiteral("SetDecorationDeepinTheme"), argumentList);
    }

    inline void SetDecorationDeepinThemeQueued(const QString &deepinThemeName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(deepinThemeName);

        CallQueued(QStringLiteral("SetDecorationDeepinTheme"), argumentList);
    }


    inline QDBusPendingReply<> SetDecorationTheme(const QString &themeType, const QString &themeName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(themeType) << QVariant::fromValue(themeName);
        return asyncCallWithArgumentList(QStringLiteral("SetDecorationTheme"), argumentList);
    }

    inline void SetDecorationThemeQueued(const QString &themeType, const QString &themeName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(themeType) << QVariant::fromValue(themeName);

        CallQueued(QStringLiteral("SetDecorationTheme"), argumentList);
    }


    inline QDBusPendingReply<> SetMultiTaskingStatus(bool isActive)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(isActive);
        return asyncCallWithArgumentList(QStringLiteral("SetMultiTaskingStatus"), argumentList);
    }

    inline void SetMultiTaskingStatusQueued(bool isActive)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(isActive);

        CallQueued(QStringLiteral("SetMultiTaskingStatus"), argumentList);
    }


    inline QDBusPendingReply<> SetShowDesktop(bool isShowDesktop)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(isShowDesktop);
        return asyncCallWithArgumentList(QStringLiteral("SetShowDesktop"), argumentList);
    }

    inline void SetShowDesktopQueued(bool isShowDesktop)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(isShowDesktop);

        CallQueued(QStringLiteral("SetShowDesktop"), argumentList);
    }


    inline QDBusPendingReply<> SetTransientBackground(const QString &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("SetTransientBackground"), argumentList);
    }

    inline void SetTransientBackgroundQueued(const QString &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);

        CallQueued(QStringLiteral("SetTransientBackground"), argumentList);
    }


    inline QDBusPendingReply<> SetTransientBackgroundForMonitor(const QString &uri, const QString &strMonitorName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri) << QVariant::fromValue(strMonitorName);
        return asyncCallWithArgumentList(QStringLiteral("SetTransientBackgroundForMonitor"), argumentList);
    }

    inline void SetTransientBackgroundForMonitorQueued(const QString &uri, const QString &strMonitorName)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(uri) << QVariant::fromValue(strMonitorName);

        CallQueued(QStringLiteral("SetTransientBackgroundForMonitor"), argumentList);
    }


    inline QDBusPendingReply<> SetWorkspaceBackground(int index, const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index) << QVariant::fromValue(uri);
        return asyncCallWithArgumentList(QStringLiteral("SetWorkspaceBackground"), argumentList);
    }

    inline void SetWorkspaceBackgroundQueued(int index, const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index) << QVariant::fromValue(uri);

        CallQueued(QStringLiteral("SetWorkspaceBackground"), argumentList);
    }


    inline QDBusPendingReply<> SetWorkspaceBackgroundForMonitor(int index, const QString &strMonitorName, const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index) << QVariant::fromValue(strMonitorName) << QVariant::fromValue(uri);
        return asyncCallWithArgumentList(QStringLiteral("SetWorkspaceBackgroundForMonitor"), argumentList);
    }

    inline void SetWorkspaceBackgroundForMonitorQueued(int index, const QString &strMonitorName, const QString &uri)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(index) << QVariant::fromValue(strMonitorName) << QVariant::fromValue(uri);

        CallQueued(QStringLiteral("SetWorkspaceBackgroundForMonitor"), argumentList);
    }


    inline QDBusPendingReply<> ShowAllWindow()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ShowAllWindow"), argumentList);
    }

    inline void ShowAllWindowQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("ShowAllWindow"), argumentList);
    }


    inline QDBusPendingReply<> ShowWindow()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ShowWindow"), argumentList);
    }

    inline void ShowWindowQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("ShowWindow"), argumentList);
    }


    inline QDBusPendingReply<> ShowWorkspace()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ShowWorkspace"), argumentList);
    }

    inline void ShowWorkspaceQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("ShowWorkspace"), argumentList);
    }


    inline QDBusPendingReply<> SwitchApplication(bool backward)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(backward);
        return asyncCallWithArgumentList(QStringLiteral("SwitchApplication"), argumentList);
    }

    inline void SwitchApplicationQueued(bool backward)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(backward);

        CallQueued(QStringLiteral("SwitchApplication"), argumentList);
    }


    inline QDBusPendingReply<> SwitchToWorkspace(bool backward)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(backward);
        return asyncCallWithArgumentList(QStringLiteral("SwitchToWorkspace"), argumentList);
    }

    inline void SwitchToWorkspaceQueued(bool backward)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(backward);

        CallQueued(QStringLiteral("SwitchToWorkspace"), argumentList);
    }


    inline QDBusPendingReply<> TileActiveWindow(uint side)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(side);
        return asyncCallWithArgumentList(QStringLiteral("TileActiveWindow"), argumentList);
    }

    inline void TileActiveWindowQueued(uint side)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(side);

        CallQueued(QStringLiteral("TileActiveWindow"), argumentList);
    }


    inline QDBusPendingReply<> ToggleActiveWindowMaximize()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ToggleActiveWindowMaximize"), argumentList);
    }

    inline void ToggleActiveWindowMaximizeQueued()
    {
        QList<QVariant> argumentList;

        CallQueued(QStringLiteral("ToggleActiveWindowMaximize"), argumentList);
    }


    inline QDBusPendingReply<> TouchToMove(int x, int y)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(x) << QVariant::fromValue(y);
        return asyncCallWithArgumentList(QStringLiteral("TouchToMove"), argumentList);
    }

    inline void TouchToMoveQueued(int x, int y)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(x) << QVariant::fromValue(y);

        CallQueued(QStringLiteral("TouchToMove"), argumentList);
    }


    inline QDBusPendingReply<int> WorkspaceCount()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("WorkspaceCount"), argumentList);
    }




Q_SIGNALS: // SIGNALS
    void WorkspaceBackgroundChanged(int index, const QString &newUri);
    void WorkspaceBackgroundChangedForMonitor(int index, const QString &strMonitorName, const QString &uri);
    void WorkspaceSwitched(int from, int to);
    void compositingEnabledChanged(bool enabled);
    void wmCompositingEnabledChanged(bool enabled);
    void workspaceCountChanged(int count);
    // begin property changed signals
    void CompositingAllowSwitchChanged(bool  value) const;
    void CompositingEnabledChanged(bool  value) const;
    void CompositingPossibleChanged(bool  value) const;
    void CursorSizeChanged(int  value) const;
    void CursorThemeChanged(const QString & value) const;
    void ZoneEnabledChanged(bool  value) const;

public Q_SLOTS:
    void CallQueued(const QString &callName, const QList<QVariant> &args);

private Q_SLOTS:
    void onPendingCallFinished(QDBusPendingCallWatcher *w);
    void onPropertyChanged(const QString &propName, const QVariant &value);

private:
    __DeepinWmPrivate *d_ptr;
};

namespace com {
  namespace deepin {
    typedef ::__DeepinWm wm;
  }
}
#endif
