/****************************************************************************
** Meta object code from reading C++ file 'com_deepin_Wm.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../../../dbusinterface/com_deepin_Wm.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'com_deepin_Wm.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN10__DeepinWmE_t {};
} // unnamed namespace

template <> constexpr inline auto __DeepinWm::qt_create_metaobjectdata<qt_meta_tag_ZN10__DeepinWmE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "__DeepinWm",
        "WorkspaceBackgroundChanged",
        "",
        "index",
        "newUri",
        "WorkspaceBackgroundChangedForMonitor",
        "strMonitorName",
        "uri",
        "WorkspaceSwitched",
        "from",
        "to",
        "compositingEnabledChanged",
        "enabled",
        "wmCompositingEnabledChanged",
        "workspaceCountChanged",
        "count",
        "CompositingAllowSwitchChanged",
        "value",
        "CompositingEnabledChanged",
        "CompositingPossibleChanged",
        "CursorSizeChanged",
        "CursorThemeChanged",
        "ZoneEnabledChanged",
        "BeginToMoveActiveWindow",
        "QDBusPendingReply<>",
        "BeginToMoveActiveWindowQueued",
        "CancelPreviewWindow",
        "CancelPreviewWindowQueued",
        "ChangeCurrentWorkspaceBackground",
        "ChangeCurrentWorkspaceBackgroundQueued",
        "ClearMoveStatus",
        "ClearMoveStatusQueued",
        "EnableZoneDetected",
        "EnableZoneDetectedQueued",
        "GetAccel",
        "QDBusPendingReply<QStringList>",
        "id",
        "GetAllAccels",
        "QDBusPendingReply<QString>",
        "GetCurrentWorkspace",
        "QDBusPendingReply<int>",
        "GetCurrentWorkspaceBackground",
        "GetCurrentWorkspaceBackgroundForMonitor",
        "GetDefaultAccel",
        "GetIsShowDesktop",
        "QDBusPendingReply<bool>",
        "GetMultiTaskingStatus",
        "GetWorkspaceBackground",
        "GetWorkspaceBackgroundForMonitor",
        "MinimizeActiveWindow",
        "MinimizeActiveWindowQueued",
        "NextWorkspace",
        "NextWorkspaceQueued",
        "PerformAction",
        "type",
        "PerformActionQueued",
        "PresentWindows",
        "QList<uint>",
        "xids",
        "PresentWindowsQueued",
        "PreviewWindow",
        "xid",
        "PreviewWindowQueued",
        "PreviousWorkspace",
        "PreviousWorkspaceQueued",
        "RemoveAccel",
        "RemoveAccelQueued",
        "SetAccel",
        "data",
        "SetCurrentWorkspace",
        "SetCurrentWorkspaceQueued",
        "SetCurrentWorkspaceBackground",
        "SetCurrentWorkspaceBackgroundQueued",
        "SetCurrentWorkspaceBackgroundForMonitor",
        "SetCurrentWorkspaceBackgroundForMonitorQueued",
        "SetDecorationDeepinTheme",
        "deepinThemeName",
        "SetDecorationDeepinThemeQueued",
        "SetDecorationTheme",
        "themeType",
        "themeName",
        "SetDecorationThemeQueued",
        "SetMultiTaskingStatus",
        "isActive",
        "SetMultiTaskingStatusQueued",
        "SetShowDesktop",
        "isShowDesktop",
        "SetShowDesktopQueued",
        "SetTransientBackground",
        "in0",
        "SetTransientBackgroundQueued",
        "SetTransientBackgroundForMonitor",
        "SetTransientBackgroundForMonitorQueued",
        "SetWorkspaceBackground",
        "SetWorkspaceBackgroundQueued",
        "SetWorkspaceBackgroundForMonitor",
        "SetWorkspaceBackgroundForMonitorQueued",
        "ShowAllWindow",
        "ShowAllWindowQueued",
        "ShowWindow",
        "ShowWindowQueued",
        "ShowWorkspace",
        "ShowWorkspaceQueued",
        "SwitchApplication",
        "backward",
        "SwitchApplicationQueued",
        "SwitchToWorkspace",
        "SwitchToWorkspaceQueued",
        "TileActiveWindow",
        "side",
        "TileActiveWindowQueued",
        "ToggleActiveWindowMaximize",
        "ToggleActiveWindowMaximizeQueued",
        "TouchToMove",
        "x",
        "y",
        "TouchToMoveQueued",
        "WorkspaceCount",
        "CallQueued",
        "callName",
        "QList<QVariant>",
        "args",
        "onPendingCallFinished",
        "QDBusPendingCallWatcher*",
        "w",
        "onPropertyChanged",
        "propName",
        "QVariant",
        "compositingAllowSwitch",
        "compositingEnabled",
        "compositingPossible",
        "cursorSize",
        "cursorTheme",
        "zoneEnabled"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'WorkspaceBackgroundChanged'
        QtMocHelpers::SignalData<void(int, const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 4 },
        }}),
        // Signal 'WorkspaceBackgroundChangedForMonitor'
        QtMocHelpers::SignalData<void(int, const QString &, const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 6 }, { QMetaType::QString, 7 },
        }}),
        // Signal 'WorkspaceSwitched'
        QtMocHelpers::SignalData<void(int, int)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 }, { QMetaType::Int, 10 },
        }}),
        // Signal 'compositingEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'wmCompositingEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'workspaceCountChanged'
        QtMocHelpers::SignalData<void(int)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 15 },
        }}),
        // Signal 'CompositingAllowSwitchChanged'
        QtMocHelpers::SignalData<void(bool) const>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'CompositingEnabledChanged'
        QtMocHelpers::SignalData<void(bool) const>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'CompositingPossibleChanged'
        QtMocHelpers::SignalData<void(bool) const>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'CursorSizeChanged'
        QtMocHelpers::SignalData<void(int) const>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Signal 'CursorThemeChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'ZoneEnabledChanged'
        QtMocHelpers::SignalData<void(bool) const>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'BeginToMoveActiveWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(23, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'BeginToMoveActiveWindowQueued'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'CancelPreviewWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(26, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'CancelPreviewWindowQueued'
        QtMocHelpers::SlotData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ChangeCurrentWorkspaceBackground'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(28, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'ChangeCurrentWorkspaceBackgroundQueued'
        QtMocHelpers::SlotData<void(const QString &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'ClearMoveStatus'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(30, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'ClearMoveStatusQueued'
        QtMocHelpers::SlotData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'EnableZoneDetected'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(32, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Bool, 12 },
        }}),
        // Slot 'EnableZoneDetectedQueued'
        QtMocHelpers::SlotData<void(bool)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Slot 'GetAccel'
        QtMocHelpers::SlotData<QDBusPendingReply<QStringList>(const QString &)>(34, 2, QMC::AccessPublic, 0x80000000 | 35, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'GetAllAccels'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(37, 2, QMC::AccessPublic, 0x80000000 | 38),
        // Slot 'GetCurrentWorkspace'
        QtMocHelpers::SlotData<QDBusPendingReply<int>()>(39, 2, QMC::AccessPublic, 0x80000000 | 40),
        // Slot 'GetCurrentWorkspaceBackground'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(41, 2, QMC::AccessPublic, 0x80000000 | 38),
        // Slot 'GetCurrentWorkspaceBackgroundForMonitor'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>(const QString &)>(42, 2, QMC::AccessPublic, 0x80000000 | 38, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'GetDefaultAccel'
        QtMocHelpers::SlotData<QDBusPendingReply<QStringList>(const QString &)>(43, 2, QMC::AccessPublic, 0x80000000 | 35, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'GetIsShowDesktop'
        QtMocHelpers::SlotData<QDBusPendingReply<bool>()>(44, 2, QMC::AccessPublic, 0x80000000 | 45),
        // Slot 'GetMultiTaskingStatus'
        QtMocHelpers::SlotData<QDBusPendingReply<bool>()>(46, 2, QMC::AccessPublic, 0x80000000 | 45),
        // Slot 'GetWorkspaceBackground'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>(int)>(47, 2, QMC::AccessPublic, 0x80000000 | 38, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'GetWorkspaceBackgroundForMonitor'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>(int, const QString &)>(48, 2, QMC::AccessPublic, 0x80000000 | 38, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'MinimizeActiveWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(49, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'MinimizeActiveWindowQueued'
        QtMocHelpers::SlotData<void()>(50, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'NextWorkspace'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(51, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'NextWorkspaceQueued'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'PerformAction'
        QtMocHelpers::SlotData<QDBusPendingReply<>(int)>(53, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'PerformActionQueued'
        QtMocHelpers::SlotData<void(int)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'PresentWindows'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QList<uint> &)>(56, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'PresentWindowsQueued'
        QtMocHelpers::SlotData<void(const QList<uint> &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Slot 'PreviewWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>(uint)>(60, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::UInt, 61 },
        }}),
        // Slot 'PreviewWindowQueued'
        QtMocHelpers::SlotData<void(uint)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 61 },
        }}),
        // Slot 'PreviousWorkspace'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(63, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'PreviousWorkspaceQueued'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'RemoveAccel'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(65, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'RemoveAccelQueued'
        QtMocHelpers::SlotData<void(const QString &)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'SetAccel'
        QtMocHelpers::SlotData<QDBusPendingReply<bool>(const QString &)>(67, 2, QMC::AccessPublic, 0x80000000 | 45, {{
            { QMetaType::QString, 68 },
        }}),
        // Slot 'SetCurrentWorkspace'
        QtMocHelpers::SlotData<QDBusPendingReply<>(int)>(69, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'SetCurrentWorkspaceQueued'
        QtMocHelpers::SlotData<void(int)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'SetCurrentWorkspaceBackground'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(71, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'SetCurrentWorkspaceBackgroundQueued'
        QtMocHelpers::SlotData<void(const QString &)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'SetCurrentWorkspaceBackgroundForMonitor'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &)>(73, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'SetCurrentWorkspaceBackgroundForMonitorQueued'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'SetDecorationDeepinTheme'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(75, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 76 },
        }}),
        // Slot 'SetDecorationDeepinThemeQueued'
        QtMocHelpers::SlotData<void(const QString &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 76 },
        }}),
        // Slot 'SetDecorationTheme'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &)>(78, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 79 }, { QMetaType::QString, 80 },
        }}),
        // Slot 'SetDecorationThemeQueued'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 79 }, { QMetaType::QString, 80 },
        }}),
        // Slot 'SetMultiTaskingStatus'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(82, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Bool, 83 },
        }}),
        // Slot 'SetMultiTaskingStatusQueued'
        QtMocHelpers::SlotData<void(bool)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 83 },
        }}),
        // Slot 'SetShowDesktop'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(85, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Bool, 86 },
        }}),
        // Slot 'SetShowDesktopQueued'
        QtMocHelpers::SlotData<void(bool)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 86 },
        }}),
        // Slot 'SetTransientBackground'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(88, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 89 },
        }}),
        // Slot 'SetTransientBackgroundQueued'
        QtMocHelpers::SlotData<void(const QString &)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 },
        }}),
        // Slot 'SetTransientBackgroundForMonitor'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &)>(91, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'SetTransientBackgroundForMonitorQueued'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'SetWorkspaceBackground'
        QtMocHelpers::SlotData<QDBusPendingReply<>(int, const QString &)>(93, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 7 },
        }}),
        // Slot 'SetWorkspaceBackgroundQueued'
        QtMocHelpers::SlotData<void(int, const QString &)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 7 },
        }}),
        // Slot 'SetWorkspaceBackgroundForMonitor'
        QtMocHelpers::SlotData<QDBusPendingReply<>(int, const QString &, const QString &)>(95, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 6 }, { QMetaType::QString, 7 },
        }}),
        // Slot 'SetWorkspaceBackgroundForMonitorQueued'
        QtMocHelpers::SlotData<void(int, const QString &, const QString &)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 }, { QMetaType::QString, 6 }, { QMetaType::QString, 7 },
        }}),
        // Slot 'ShowAllWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(97, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'ShowAllWindowQueued'
        QtMocHelpers::SlotData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ShowWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(99, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'ShowWindowQueued'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ShowWorkspace'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(101, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'ShowWorkspaceQueued'
        QtMocHelpers::SlotData<void()>(102, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'SwitchApplication'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(103, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Bool, 104 },
        }}),
        // Slot 'SwitchApplicationQueued'
        QtMocHelpers::SlotData<void(bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 104 },
        }}),
        // Slot 'SwitchToWorkspace'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(106, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Bool, 104 },
        }}),
        // Slot 'SwitchToWorkspaceQueued'
        QtMocHelpers::SlotData<void(bool)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 104 },
        }}),
        // Slot 'TileActiveWindow'
        QtMocHelpers::SlotData<QDBusPendingReply<>(uint)>(108, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::UInt, 109 },
        }}),
        // Slot 'TileActiveWindowQueued'
        QtMocHelpers::SlotData<void(uint)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 109 },
        }}),
        // Slot 'ToggleActiveWindowMaximize'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(111, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'ToggleActiveWindowMaximizeQueued'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'TouchToMove'
        QtMocHelpers::SlotData<QDBusPendingReply<>(int, int)>(113, 2, QMC::AccessPublic, 0x80000000 | 24, {{
            { QMetaType::Int, 114 }, { QMetaType::Int, 115 },
        }}),
        // Slot 'TouchToMoveQueued'
        QtMocHelpers::SlotData<void(int, int)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 114 }, { QMetaType::Int, 115 },
        }}),
        // Slot 'WorkspaceCount'
        QtMocHelpers::SlotData<QDBusPendingReply<int>()>(117, 2, QMC::AccessPublic, 0x80000000 | 40),
        // Slot 'CallQueued'
        QtMocHelpers::SlotData<void(const QString &, const QList<QVariant> &)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 119 }, { 0x80000000 | 120, 121 },
        }}),
        // Slot 'onPendingCallFinished'
        QtMocHelpers::SlotData<void(QDBusPendingCallWatcher *)>(122, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 123, 124 },
        }}),
        // Slot 'onPropertyChanged'
        QtMocHelpers::SlotData<void(const QString &, const QVariant &)>(125, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 126 }, { 0x80000000 | 127, 17 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'compositingAllowSwitch'
        QtMocHelpers::PropertyData<bool>(128, QMetaType::Bool, QMC::DefaultPropertyFlags, 6),
        // property 'compositingEnabled'
        QtMocHelpers::PropertyData<bool>(129, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'compositingPossible'
        QtMocHelpers::PropertyData<bool>(130, QMetaType::Bool, QMC::DefaultPropertyFlags, 8),
        // property 'cursorSize'
        QtMocHelpers::PropertyData<int>(131, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'cursorTheme'
        QtMocHelpers::PropertyData<QString>(132, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'zoneEnabled'
        QtMocHelpers::PropertyData<bool>(133, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<__DeepinWm, qt_meta_tag_ZN10__DeepinWmE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject __DeepinWm::staticMetaObject = { {
    QMetaObject::SuperData::link<Dtk::Core::DDBusExtendedAbstractInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10__DeepinWmE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10__DeepinWmE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10__DeepinWmE_t>.metaTypes,
    nullptr
} };

void __DeepinWm::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<__DeepinWm *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->WorkspaceBackgroundChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 1: _t->WorkspaceBackgroundChangedForMonitor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 2: _t->WorkspaceSwitched((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 3: _t->compositingEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->wmCompositingEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->workspaceCountChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 6: _t->CompositingAllowSwitchChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->CompositingEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->CompositingPossibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->CursorSizeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->CursorThemeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 11: _t->ZoneEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: { QDBusPendingReply<> _r = _t->BeginToMoveActiveWindow();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 13: _t->BeginToMoveActiveWindowQueued(); break;
        case 14: { QDBusPendingReply<> _r = _t->CancelPreviewWindow();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 15: _t->CancelPreviewWindowQueued(); break;
        case 16: { QDBusPendingReply<> _r = _t->ChangeCurrentWorkspaceBackground((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 17: _t->ChangeCurrentWorkspaceBackgroundQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: { QDBusPendingReply<> _r = _t->ClearMoveStatus();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 19: _t->ClearMoveStatusQueued(); break;
        case 20: { QDBusPendingReply<> _r = _t->EnableZoneDetected((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 21: _t->EnableZoneDetectedQueued((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: { QDBusPendingReply<QStringList> _r = _t->GetAccel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QStringList>*>(_a[0]) = std::move(_r); }  break;
        case 23: { QDBusPendingReply<QString> _r = _t->GetAllAccels();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 24: { QDBusPendingReply<int> _r = _t->GetCurrentWorkspace();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<int>*>(_a[0]) = std::move(_r); }  break;
        case 25: { QDBusPendingReply<QString> _r = _t->GetCurrentWorkspaceBackground();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 26: { QDBusPendingReply<QString> _r = _t->GetCurrentWorkspaceBackgroundForMonitor((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 27: { QDBusPendingReply<QStringList> _r = _t->GetDefaultAccel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QStringList>*>(_a[0]) = std::move(_r); }  break;
        case 28: { QDBusPendingReply<bool> _r = _t->GetIsShowDesktop();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); }  break;
        case 29: { QDBusPendingReply<bool> _r = _t->GetMultiTaskingStatus();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); }  break;
        case 30: { QDBusPendingReply<QString> _r = _t->GetWorkspaceBackground((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 31: { QDBusPendingReply<QString> _r = _t->GetWorkspaceBackgroundForMonitor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 32: { QDBusPendingReply<> _r = _t->MinimizeActiveWindow();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 33: _t->MinimizeActiveWindowQueued(); break;
        case 34: { QDBusPendingReply<> _r = _t->NextWorkspace();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 35: _t->NextWorkspaceQueued(); break;
        case 36: { QDBusPendingReply<> _r = _t->PerformAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 37: _t->PerformActionQueued((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 38: { QDBusPendingReply<> _r = _t->PresentWindows((*reinterpret_cast<std::add_pointer_t<QList<uint>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 39: _t->PresentWindowsQueued((*reinterpret_cast<std::add_pointer_t<QList<uint>>>(_a[1]))); break;
        case 40: { QDBusPendingReply<> _r = _t->PreviewWindow((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 41: _t->PreviewWindowQueued((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 42: { QDBusPendingReply<> _r = _t->PreviousWorkspace();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 43: _t->PreviousWorkspaceQueued(); break;
        case 44: { QDBusPendingReply<> _r = _t->RemoveAccel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 45: _t->RemoveAccelQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 46: { QDBusPendingReply<bool> _r = _t->SetAccel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); }  break;
        case 47: { QDBusPendingReply<> _r = _t->SetCurrentWorkspace((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 48: _t->SetCurrentWorkspaceQueued((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 49: { QDBusPendingReply<> _r = _t->SetCurrentWorkspaceBackground((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 50: _t->SetCurrentWorkspaceBackgroundQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 51: { QDBusPendingReply<> _r = _t->SetCurrentWorkspaceBackgroundForMonitor((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 52: _t->SetCurrentWorkspaceBackgroundForMonitorQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 53: { QDBusPendingReply<> _r = _t->SetDecorationDeepinTheme((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 54: _t->SetDecorationDeepinThemeQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 55: { QDBusPendingReply<> _r = _t->SetDecorationTheme((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 56: _t->SetDecorationThemeQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 57: { QDBusPendingReply<> _r = _t->SetMultiTaskingStatus((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 58: _t->SetMultiTaskingStatusQueued((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 59: { QDBusPendingReply<> _r = _t->SetShowDesktop((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 60: _t->SetShowDesktopQueued((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 61: { QDBusPendingReply<> _r = _t->SetTransientBackground((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 62: _t->SetTransientBackgroundQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 63: { QDBusPendingReply<> _r = _t->SetTransientBackgroundForMonitor((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 64: _t->SetTransientBackgroundForMonitorQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 65: { QDBusPendingReply<> _r = _t->SetWorkspaceBackground((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 66: _t->SetWorkspaceBackgroundQueued((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 67: { QDBusPendingReply<> _r = _t->SetWorkspaceBackgroundForMonitor((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 68: _t->SetWorkspaceBackgroundForMonitorQueued((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 69: { QDBusPendingReply<> _r = _t->ShowAllWindow();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 70: _t->ShowAllWindowQueued(); break;
        case 71: { QDBusPendingReply<> _r = _t->ShowWindow();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 72: _t->ShowWindowQueued(); break;
        case 73: { QDBusPendingReply<> _r = _t->ShowWorkspace();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 74: _t->ShowWorkspaceQueued(); break;
        case 75: { QDBusPendingReply<> _r = _t->SwitchApplication((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 76: _t->SwitchApplicationQueued((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 77: { QDBusPendingReply<> _r = _t->SwitchToWorkspace((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 78: _t->SwitchToWorkspaceQueued((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 79: { QDBusPendingReply<> _r = _t->TileActiveWindow((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 80: _t->TileActiveWindowQueued((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 81: { QDBusPendingReply<> _r = _t->ToggleActiveWindowMaximize();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 82: _t->ToggleActiveWindowMaximizeQueued(); break;
        case 83: { QDBusPendingReply<> _r = _t->TouchToMove((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 84: _t->TouchToMoveQueued((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 85: { QDBusPendingReply<int> _r = _t->WorkspaceCount();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<int>*>(_a[0]) = std::move(_r); }  break;
        case 86: _t->CallQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[2]))); break;
        case 87: _t->onPendingCallFinished((*reinterpret_cast<std::add_pointer_t<QDBusPendingCallWatcher*>>(_a[1]))); break;
        case 88: _t->onPropertyChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 38:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<uint> >(); break;
            }
            break;
        case 39:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<uint> >(); break;
            }
            break;
        case 87:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusPendingCallWatcher* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(int , const QString & )>(_a, &__DeepinWm::WorkspaceBackgroundChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(int , const QString & , const QString & )>(_a, &__DeepinWm::WorkspaceBackgroundChangedForMonitor, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(int , int )>(_a, &__DeepinWm::WorkspaceSwitched, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(bool )>(_a, &__DeepinWm::compositingEnabledChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(bool )>(_a, &__DeepinWm::wmCompositingEnabledChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(int )>(_a, &__DeepinWm::workspaceCountChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(bool ) const>(_a, &__DeepinWm::CompositingAllowSwitchChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(bool ) const>(_a, &__DeepinWm::CompositingEnabledChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(bool ) const>(_a, &__DeepinWm::CompositingPossibleChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(int ) const>(_a, &__DeepinWm::CursorSizeChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(const QString & ) const>(_a, &__DeepinWm::CursorThemeChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (__DeepinWm::*)(bool ) const>(_a, &__DeepinWm::ZoneEnabledChanged, 11))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->compositingAllowSwitch(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->compositingEnabled(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->compositingPossible(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->cursorSize(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->cursorTheme(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->zoneEnabled(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 1: _t->setCompositingEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->setCursorSize(*reinterpret_cast<int*>(_v)); break;
        case 4: _t->setCursorTheme(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setZoneEnabled(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *__DeepinWm::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *__DeepinWm::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10__DeepinWmE_t>.strings))
        return static_cast<void*>(this);
    return Dtk::Core::DDBusExtendedAbstractInterface::qt_metacast(_clname);
}

int __DeepinWm::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Dtk::Core::DDBusExtendedAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 89)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 89;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 89)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 89;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    }
    return _id;
}

// SIGNAL 0
void __DeepinWm::WorkspaceBackgroundChanged(int _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void __DeepinWm::WorkspaceBackgroundChangedForMonitor(int _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2, _t3);
}

// SIGNAL 2
void __DeepinWm::WorkspaceSwitched(int _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 3
void __DeepinWm::compositingEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void __DeepinWm::wmCompositingEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void __DeepinWm::workspaceCountChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void __DeepinWm::CompositingAllowSwitchChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __DeepinWm *>(this), &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void __DeepinWm::CompositingEnabledChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __DeepinWm *>(this), &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void __DeepinWm::CompositingPossibleChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __DeepinWm *>(this), &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void __DeepinWm::CursorSizeChanged(int _t1)const
{
    QMetaObject::activate<void>(const_cast< __DeepinWm *>(this), &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void __DeepinWm::CursorThemeChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __DeepinWm *>(this), &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void __DeepinWm::ZoneEnabledChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __DeepinWm *>(this), &staticMetaObject, 11, nullptr, _t1);
}
QT_WARNING_POP
