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

#include "../../../../src/modules/dde-shell/ddeshellmanagerinterfacev1.h"
#include "private/wserver_p.h"
#include <wsurface.h>
#include "woutput.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'ddeshellmanagerinterfacev1.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. 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_ZN26DDEShellManagerInterfaceV1E_t {};
} // unnamed namespace

template <> constexpr inline auto DDEShellManagerInterfaceV1::qt_create_metaobjectdata<qt_meta_tag_ZN26DDEShellManagerInterfaceV1E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DDEShellManagerInterfaceV1",
        "surfaceCreated",
        "",
        "DDEShellSurfaceInterface*",
        "interface",
        "activeCreated",
        "DDEActiveInterface*",
        "windowOverlapCheckerCreated",
        "WindowOverlapCheckerInterface*",
        "multiTaskViewsCreated",
        "MultiTaskViewInterface*",
        "PickerCreated",
        "WindowPickerInterface*",
        "lockScreenCreated",
        "LockScreenInterface*",
        "toggleMultitaskview",
        "requestPickWindow",
        "picker"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'surfaceCreated'
        QtMocHelpers::SignalData<void(DDEShellSurfaceInterface *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'activeCreated'
        QtMocHelpers::SignalData<void(DDEActiveInterface *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 4 },
        }}),
        // Signal 'windowOverlapCheckerCreated'
        QtMocHelpers::SignalData<void(WindowOverlapCheckerInterface *)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 4 },
        }}),
        // Signal 'multiTaskViewsCreated'
        QtMocHelpers::SignalData<void(MultiTaskViewInterface *)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 4 },
        }}),
        // Signal 'PickerCreated'
        QtMocHelpers::SignalData<void(WindowPickerInterface *)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 4 },
        }}),
        // Signal 'lockScreenCreated'
        QtMocHelpers::SignalData<void(LockScreenInterface *)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 14, 4 },
        }}),
        // Signal 'toggleMultitaskview'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'requestPickWindow'
        QtMocHelpers::SignalData<void(WindowPickerInterface *)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 17 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DDEShellManagerInterfaceV1, qt_meta_tag_ZN26DDEShellManagerInterfaceV1E_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DDEShellManagerInterfaceV1::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DDEShellManagerInterfaceV1E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DDEShellManagerInterfaceV1E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26DDEShellManagerInterfaceV1E_t>.metaTypes,
    nullptr
} };

void DDEShellManagerInterfaceV1::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DDEShellManagerInterfaceV1 *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->surfaceCreated((*reinterpret_cast<std::add_pointer_t<DDEShellSurfaceInterface*>>(_a[1]))); break;
        case 1: _t->activeCreated((*reinterpret_cast<std::add_pointer_t<DDEActiveInterface*>>(_a[1]))); break;
        case 2: _t->windowOverlapCheckerCreated((*reinterpret_cast<std::add_pointer_t<WindowOverlapCheckerInterface*>>(_a[1]))); break;
        case 3: _t->multiTaskViewsCreated((*reinterpret_cast<std::add_pointer_t<MultiTaskViewInterface*>>(_a[1]))); break;
        case 4: _t->PickerCreated((*reinterpret_cast<std::add_pointer_t<WindowPickerInterface*>>(_a[1]))); break;
        case 5: _t->lockScreenCreated((*reinterpret_cast<std::add_pointer_t<LockScreenInterface*>>(_a[1]))); break;
        case 6: _t->toggleMultitaskview(); break;
        case 7: _t->requestPickWindow((*reinterpret_cast<std::add_pointer_t<WindowPickerInterface*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DDEShellSurfaceInterface* >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DDEActiveInterface* >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< WindowOverlapCheckerInterface* >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MultiTaskViewInterface* >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< WindowPickerInterface* >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LockScreenInterface* >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< WindowPickerInterface* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(DDEShellSurfaceInterface * )>(_a, &DDEShellManagerInterfaceV1::surfaceCreated, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(DDEActiveInterface * )>(_a, &DDEShellManagerInterfaceV1::activeCreated, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(WindowOverlapCheckerInterface * )>(_a, &DDEShellManagerInterfaceV1::windowOverlapCheckerCreated, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(MultiTaskViewInterface * )>(_a, &DDEShellManagerInterfaceV1::multiTaskViewsCreated, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(WindowPickerInterface * )>(_a, &DDEShellManagerInterfaceV1::PickerCreated, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(LockScreenInterface * )>(_a, &DDEShellManagerInterfaceV1::lockScreenCreated, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)()>(_a, &DDEShellManagerInterfaceV1::toggleMultitaskview, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellManagerInterfaceV1::*)(WindowPickerInterface * )>(_a, &DDEShellManagerInterfaceV1::requestPickWindow, 7))
            return;
    }
}

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

void *DDEShellManagerInterfaceV1::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DDEShellManagerInterfaceV1E_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "WServerInterface"))
        return static_cast< WServerInterface*>(this);
    return QObject::qt_metacast(_clname);
}

int DDEShellManagerInterfaceV1::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void DDEShellManagerInterfaceV1::surfaceCreated(DDEShellSurfaceInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void DDEShellManagerInterfaceV1::activeCreated(DDEActiveInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void DDEShellManagerInterfaceV1::windowOverlapCheckerCreated(WindowOverlapCheckerInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void DDEShellManagerInterfaceV1::multiTaskViewsCreated(MultiTaskViewInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void DDEShellManagerInterfaceV1::PickerCreated(WindowPickerInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void DDEShellManagerInterfaceV1::lockScreenCreated(LockScreenInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void DDEShellManagerInterfaceV1::toggleMultitaskview()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void DDEShellManagerInterfaceV1::requestPickWindow(WindowPickerInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto DDEShellSurfaceInterface::qt_create_metaobjectdata<qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DDEShellSurfaceInterface",
        "positionChanged",
        "",
        "QPoint",
        "pos",
        "roleChanged",
        "DDEShellSurfaceInterface::Role",
        "role",
        "yOffsetChanged",
        "uint32_t",
        "offset",
        "skipSwitcherChanged",
        "skip",
        "skipDockPreViewChanged",
        "skipMutiTaskViewChanged",
        "acceptKeyboardFocusChanged",
        "accept"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'positionChanged'
        QtMocHelpers::SignalData<void(QPoint)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'roleChanged'
        QtMocHelpers::SignalData<void(DDEShellSurfaceInterface::Role)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'yOffsetChanged'
        QtMocHelpers::SignalData<void(uint32_t)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'skipSwitcherChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'skipDockPreViewChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'skipMutiTaskViewChanged'
        QtMocHelpers::SignalData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'acceptKeyboardFocusChanged'
        QtMocHelpers::SignalData<void(bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 16 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DDEShellSurfaceInterface, qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DDEShellSurfaceInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t>.metaTypes,
    nullptr
} };

void DDEShellSurfaceInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DDEShellSurfaceInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->positionChanged((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 1: _t->roleChanged((*reinterpret_cast<std::add_pointer_t<DDEShellSurfaceInterface::Role>>(_a[1]))); break;
        case 2: _t->yOffsetChanged((*reinterpret_cast<std::add_pointer_t<uint32_t>>(_a[1]))); break;
        case 3: _t->skipSwitcherChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->skipDockPreViewChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->skipMutiTaskViewChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->acceptKeyboardFocusChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(QPoint )>(_a, &DDEShellSurfaceInterface::positionChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(DDEShellSurfaceInterface::Role )>(_a, &DDEShellSurfaceInterface::roleChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(uint32_t )>(_a, &DDEShellSurfaceInterface::yOffsetChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(bool )>(_a, &DDEShellSurfaceInterface::skipSwitcherChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(bool )>(_a, &DDEShellSurfaceInterface::skipDockPreViewChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(bool )>(_a, &DDEShellSurfaceInterface::skipMutiTaskViewChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DDEShellSurfaceInterface::*)(bool )>(_a, &DDEShellSurfaceInterface::acceptKeyboardFocusChanged, 6))
            return;
    }
}

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

void *DDEShellSurfaceInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DDEShellSurfaceInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int DDEShellSurfaceInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 7)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 7;
    }
    return _id;
}

// SIGNAL 0
void DDEShellSurfaceInterface::positionChanged(QPoint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void DDEShellSurfaceInterface::roleChanged(DDEShellSurfaceInterface::Role _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void DDEShellSurfaceInterface::yOffsetChanged(uint32_t _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

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

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

// SIGNAL 5
void DDEShellSurfaceInterface::skipMutiTaskViewChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void DDEShellSurfaceInterface::acceptKeyboardFocusChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN18DDEActiveInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto DDEActiveInterface::qt_create_metaobjectdata<qt_meta_tag_ZN18DDEActiveInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DDEActiveInterface"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DDEActiveInterface, qt_meta_tag_ZN18DDEActiveInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DDEActiveInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18DDEActiveInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18DDEActiveInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18DDEActiveInterfaceE_t>.metaTypes,
    nullptr
} };

void DDEActiveInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DDEActiveInterface *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *DDEActiveInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18DDEActiveInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int DDEActiveInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto WindowOverlapCheckerInterface::qt_create_metaobjectdata<qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "WindowOverlapCheckerInterface",
        "refresh",
        "",
        "Anchor",
        "TOP",
        "BOTTOM",
        "LEFT",
        "RIGHT"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'refresh'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Anchor'
        QtMocHelpers::EnumData<enum Anchor>(3, 3, QMC::EnumFlags{}).add({
            {    4, Anchor::TOP },
            {    5, Anchor::BOTTOM },
            {    6, Anchor::LEFT },
            {    7, Anchor::RIGHT },
        }),
    };
    return QtMocHelpers::metaObjectData<WindowOverlapCheckerInterface, qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject WindowOverlapCheckerInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t>.metaTypes,
    nullptr
} };

void WindowOverlapCheckerInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<WindowOverlapCheckerInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->refresh(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (WindowOverlapCheckerInterface::*)()>(_a, &WindowOverlapCheckerInterface::refresh, 0))
            return;
    }
}

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

void *WindowOverlapCheckerInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29WindowOverlapCheckerInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int WindowOverlapCheckerInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void WindowOverlapCheckerInterface::refresh()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN22MultiTaskViewInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto MultiTaskViewInterface::qt_create_metaobjectdata<qt_meta_tag_ZN22MultiTaskViewInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "MultiTaskViewInterface",
        "toggle",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'toggle'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<MultiTaskViewInterface, qt_meta_tag_ZN22MultiTaskViewInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject MultiTaskViewInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22MultiTaskViewInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22MultiTaskViewInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22MultiTaskViewInterfaceE_t>.metaTypes,
    nullptr
} };

void MultiTaskViewInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<MultiTaskViewInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->toggle(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (MultiTaskViewInterface::*)()>(_a, &MultiTaskViewInterface::toggle, 0))
            return;
    }
}

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

void *MultiTaskViewInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22MultiTaskViewInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int MultiTaskViewInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void MultiTaskViewInterface::toggle()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN21WindowPickerInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto WindowPickerInterface::qt_create_metaobjectdata<qt_meta_tag_ZN21WindowPickerInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "WindowPickerInterface",
        "pick",
        "",
        "hint",
        "beforeDestroy"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'pick'
        QtMocHelpers::SignalData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'beforeDestroy'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<WindowPickerInterface, qt_meta_tag_ZN21WindowPickerInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject WindowPickerInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21WindowPickerInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21WindowPickerInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21WindowPickerInterfaceE_t>.metaTypes,
    nullptr
} };

void WindowPickerInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<WindowPickerInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->pick((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->beforeDestroy(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (WindowPickerInterface::*)(const QString & )>(_a, &WindowPickerInterface::pick, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (WindowPickerInterface::*)()>(_a, &WindowPickerInterface::beforeDestroy, 1))
            return;
    }
}

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

void *WindowPickerInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21WindowPickerInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int WindowPickerInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void WindowPickerInterface::pick(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void WindowPickerInterface::beforeDestroy()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN19LockScreenInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto LockScreenInterface::qt_create_metaobjectdata<qt_meta_tag_ZN19LockScreenInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LockScreenInterface",
        "lock",
        "",
        "shutdown",
        "switchUser"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'lock'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shutdown'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'switchUser'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LockScreenInterface, qt_meta_tag_ZN19LockScreenInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LockScreenInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19LockScreenInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19LockScreenInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19LockScreenInterfaceE_t>.metaTypes,
    nullptr
} };

void LockScreenInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<LockScreenInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->lock(); break;
        case 1: _t->shutdown(); break;
        case 2: _t->switchUser(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (LockScreenInterface::*)()>(_a, &LockScreenInterface::lock, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (LockScreenInterface::*)()>(_a, &LockScreenInterface::shutdown, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (LockScreenInterface::*)()>(_a, &LockScreenInterface::switchUser, 2))
            return;
    }
}

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

void *LockScreenInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19LockScreenInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int LockScreenInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void LockScreenInterface::lock()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void LockScreenInterface::shutdown()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void LockScreenInterface::switchUser()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
QT_WARNING_POP
