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

#include "../../../../../qtwayland/src/compositor/extensions/qwaylandxdgshell.h"
#include "qwaylandsurface.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 'qwaylandxdgshell.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.0. 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_ZN16QWaylandXdgShellE_t {};
} // unnamed namespace

template <> constexpr inline auto QWaylandXdgShell::qt_create_metaobjectdata<qt_meta_tag_ZN16QWaylandXdgShellE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QWaylandXdgShell",
        "xdgSurfaceCreated",
        "",
        "QWaylandXdgSurface*",
        "xdgSurface",
        "toplevelCreated",
        "QWaylandXdgToplevel*",
        "toplevel",
        "popupCreated",
        "QWaylandXdgPopup*",
        "popup",
        "pong",
        "serial",
        "ping",
        "QWaylandClient*",
        "client",
        "handleSeatChanged",
        "QWaylandSeat*",
        "newSeat",
        "oldSeat",
        "handleFocusChanged",
        "QWaylandSurface*",
        "newSurface",
        "oldSurface"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'xdgSurfaceCreated'
        QtMocHelpers::SignalData<void(QWaylandXdgSurface *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'toplevelCreated'
        QtMocHelpers::SignalData<void(QWaylandXdgToplevel *, QWaylandXdgSurface *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 3, 4 },
        }}),
        // Signal 'popupCreated'
        QtMocHelpers::SignalData<void(QWaylandXdgPopup *, QWaylandXdgSurface *)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 3, 4 },
        }}),
        // Signal 'pong'
        QtMocHelpers::SignalData<void(uint)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 12 },
        }}),
        // Slot 'ping'
        QtMocHelpers::SlotData<uint(QWaylandClient *)>(13, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 14, 15 },
        }}),
        // Slot 'handleSeatChanged'
        QtMocHelpers::SlotData<void(QWaylandSeat *, QWaylandSeat *)>(16, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 17, 18 }, { 0x80000000 | 17, 19 },
        }}),
        // Slot 'handleFocusChanged'
        QtMocHelpers::SlotData<void(QWaylandSurface *, QWaylandSurface *)>(20, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 21, 22 }, { 0x80000000 | 21, 23 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QWaylandXdgShell, qt_meta_tag_ZN16QWaylandXdgShellE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QWaylandXdgShell::staticMetaObject = { {
    QMetaObject::SuperData::link<QWaylandShellTemplate<QWaylandXdgShell>::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QWaylandXdgShellE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QWaylandXdgShellE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QWaylandXdgShellE_t>.metaTypes,
    nullptr
} };

void QWaylandXdgShell::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QWaylandXdgShell *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->xdgSurfaceCreated((*reinterpret_cast<std::add_pointer_t<QWaylandXdgSurface*>>(_a[1]))); break;
        case 1: _t->toplevelCreated((*reinterpret_cast<std::add_pointer_t<QWaylandXdgToplevel*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandXdgSurface*>>(_a[2]))); break;
        case 2: _t->popupCreated((*reinterpret_cast<std::add_pointer_t<QWaylandXdgPopup*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandXdgSurface*>>(_a[2]))); break;
        case 3: _t->pong((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 4: { uint _r = _t->ping((*reinterpret_cast<std::add_pointer_t<QWaylandClient*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 5: _t->handleSeatChanged((*reinterpret_cast<std::add_pointer_t<QWaylandSeat*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandSeat*>>(_a[2]))); break;
        case 6: _t->handleFocusChanged((*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[2]))); 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< QWaylandXdgSurface* >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandXdgSurface* >(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandXdgToplevel* >(); 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< QWaylandXdgPopup* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandXdgSurface* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgShell::*)(QWaylandXdgSurface * )>(_a, &QWaylandXdgShell::xdgSurfaceCreated, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgShell::*)(QWaylandXdgToplevel * , QWaylandXdgSurface * )>(_a, &QWaylandXdgShell::toplevelCreated, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgShell::*)(QWaylandXdgPopup * , QWaylandXdgSurface * )>(_a, &QWaylandXdgShell::popupCreated, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgShell::*)(uint )>(_a, &QWaylandXdgShell::pong, 3))
            return;
    }
}

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

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

int QWaylandXdgShell::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWaylandShellTemplate<QWaylandXdgShell>::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)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    return _id;
}

// SIGNAL 0
void QWaylandXdgShell::xdgSurfaceCreated(QWaylandXdgSurface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void QWaylandXdgShell::toplevelCreated(QWaylandXdgToplevel * _t1, QWaylandXdgSurface * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void QWaylandXdgShell::popupCreated(QWaylandXdgPopup * _t1, QWaylandXdgSurface * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 3
void QWaylandXdgShell::pong(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN18QWaylandXdgSurfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto QWaylandXdgSurface::qt_create_metaobjectdata<qt_meta_tag_ZN18QWaylandXdgSurfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QWaylandXdgSurface",
        "DefaultProperty",
        "data",
        "shellChanged",
        "",
        "surfaceChanged",
        "toplevelCreated",
        "popupCreated",
        "windowGeometryChanged",
        "handleSurfaceSizeChanged",
        "handleBufferScaleChanged",
        "initialize",
        "QWaylandXdgShell*",
        "xdgShell",
        "QWaylandSurface*",
        "surface",
        "QWaylandResource",
        "resource",
        "QQmlListProperty<QObject>",
        "shell",
        "toplevel",
        "QWaylandXdgToplevel*",
        "popup",
        "QWaylandXdgPopup*",
        "windowGeometry",
        "QRect"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'shellChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'surfaceChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'toplevelCreated'
        QtMocHelpers::SignalData<void()>(6, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'popupCreated'
        QtMocHelpers::SignalData<void()>(7, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'windowGeometryChanged'
        QtMocHelpers::SignalData<void()>(8, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'handleSurfaceSizeChanged'
        QtMocHelpers::SlotData<void()>(9, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'handleBufferScaleChanged'
        QtMocHelpers::SlotData<void()>(10, 4, QMC::AccessPrivate, QMetaType::Void),
        // Method 'initialize'
        QtMocHelpers::MethodData<void(QWaylandXdgShell *, QWaylandSurface *, const QWaylandResource &)>(11, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 }, { 0x80000000 | 14, 15 }, { 0x80000000 | 16, 17 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'data'
        QtMocHelpers::PropertyData<QQmlListProperty<QObject>>(2, 0x80000000 | 18, QMC::Readable | QMC::Scriptable | QMC::Stored | QMC::EnumOrFlag),
        // property 'shell'
        QtMocHelpers::PropertyData<QWaylandXdgShell*>(19, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'surface'
        QtMocHelpers::PropertyData<QWaylandSurface*>(15, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'toplevel'
        QtMocHelpers::PropertyData<QWaylandXdgToplevel*>(20, 0x80000000 | 21, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
        // property 'popup'
        QtMocHelpers::PropertyData<QWaylandXdgPopup*>(22, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 3),
        // property 'windowGeometry'
        QtMocHelpers::PropertyData<QRect>(24, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 4),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<QWaylandXdgSurface, qt_meta_tag_ZN18QWaylandXdgSurfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QWaylandXdgSurface::staticMetaObject = { {
    QMetaObject::SuperData::link<QWaylandShellSurfaceTemplate<QWaylandXdgSurface>::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QWaylandXdgSurfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QWaylandXdgSurfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QWaylandXdgSurfaceE_t>.metaTypes,
    nullptr
} };

void QWaylandXdgSurface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QWaylandXdgSurface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->shellChanged(); break;
        case 1: _t->surfaceChanged(); break;
        case 2: _t->toplevelCreated(); break;
        case 3: _t->popupCreated(); break;
        case 4: _t->windowGeometryChanged(); break;
        case 5: _t->handleSurfaceSizeChanged(); break;
        case 6: _t->handleBufferScaleChanged(); break;
        case 7: _t->initialize((*reinterpret_cast<std::add_pointer_t<QWaylandXdgShell*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QWaylandResource>>(_a[3]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandResource >(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandXdgShell* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgSurface::*)()>(_a, &QWaylandXdgSurface::shellChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgSurface::*)()>(_a, &QWaylandXdgSurface::surfaceChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgSurface::*)()>(_a, &QWaylandXdgSurface::toplevelCreated, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgSurface::*)()>(_a, &QWaylandXdgSurface::popupCreated, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgSurface::*)()>(_a, &QWaylandXdgSurface::windowGeometryChanged, 4))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 4:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandXdgPopup* >(); break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandXdgShell* >(); break;
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandXdgToplevel* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QQmlListProperty<QObject>*>(_v) = _t->data(); break;
        case 1: *reinterpret_cast<QWaylandXdgShell**>(_v) = _t->shell(); break;
        case 2: *reinterpret_cast<QWaylandSurface**>(_v) = _t->surface(); break;
        case 3: *reinterpret_cast<QWaylandXdgToplevel**>(_v) = _t->toplevel(); break;
        case 4: *reinterpret_cast<QWaylandXdgPopup**>(_v) = _t->popup(); break;
        case 5: *reinterpret_cast<QRect*>(_v) = _t->windowGeometry(); break;
        default: break;
        }
    }
}

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

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

int QWaylandXdgSurface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWaylandShellSurfaceTemplate<QWaylandXdgSurface>::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;
    }
    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 QWaylandXdgSurface::shellChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

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

// SIGNAL 2
void QWaylandXdgSurface::toplevelCreated()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void QWaylandXdgSurface::popupCreated()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void QWaylandXdgSurface::windowGeometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}
namespace {
struct qt_meta_tag_ZN19QWaylandXdgToplevelE_t {};
} // unnamed namespace

template <> constexpr inline auto QWaylandXdgToplevel::qt_create_metaobjectdata<qt_meta_tag_ZN19QWaylandXdgToplevelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QWaylandXdgToplevel",
        "parentToplevelChanged",
        "",
        "titleChanged",
        "appIdChanged",
        "maxSizeChanged",
        "minSizeChanged",
        "startMove",
        "QWaylandSeat*",
        "seat",
        "startResize",
        "Qt::Edges",
        "edges",
        "statesChanged",
        "maximizedChanged",
        "fullscreenChanged",
        "resizingChanged",
        "activatedChanged",
        "showWindowMenu",
        "QPoint",
        "localSurfacePosition",
        "setMaximized",
        "unsetMaximized",
        "setFullscreen",
        "QWaylandOutput*",
        "output",
        "unsetFullscreen",
        "setMinimized",
        "decorationModeChanged",
        "modalChanged",
        "sizeForResize",
        "QSize",
        "QSizeF",
        "size",
        "QPointF",
        "delta",
        "sendConfigure",
        "QList<int>",
        "states",
        "sendClose",
        "sendMaximized",
        "sendUnmaximized",
        "sendFullscreen",
        "sendResizing",
        "xdgSurface",
        "QWaylandXdgSurface*",
        "parentToplevel",
        "QWaylandXdgToplevel*",
        "title",
        "appId",
        "maxSize",
        "minSize",
        "maximized",
        "fullscreen",
        "resizing",
        "activated",
        "modal",
        "decorationMode",
        "DecorationMode",
        "State",
        "MaximizedState",
        "FullscreenState",
        "ResizingState",
        "ActivatedState",
        "ClientSideDecoration",
        "ServerSideDecoration"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'parentToplevelChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'titleChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'appIdChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'maxSizeChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'minSizeChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'startMove'
        QtMocHelpers::SignalData<void(QWaylandSeat *)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'startResize'
        QtMocHelpers::SignalData<void(QWaylandSeat *, Qt::Edges)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 }, { 0x80000000 | 11, 12 },
        }}),
        // Signal 'statesChanged'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'maximizedChanged'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fullscreenChanged'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'resizingChanged'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activatedChanged'
        QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showWindowMenu'
        QtMocHelpers::SignalData<void(QWaylandSeat *, const QPoint &)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 }, { 0x80000000 | 19, 20 },
        }}),
        // Signal 'setMaximized'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'unsetMaximized'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'setFullscreen'
        QtMocHelpers::SignalData<void(QWaylandOutput *)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 24, 25 },
        }}),
        // Signal 'unsetFullscreen'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'setMinimized'
        QtMocHelpers::SignalData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'decorationModeChanged'
        QtMocHelpers::SignalData<void()>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'modalChanged'
        QtMocHelpers::RevisionedSignalData<void()>(29, 2, QMC::AccessPublic, 0x608, QMetaType::Void),
        // Method 'sizeForResize'
        QtMocHelpers::MethodData<QSize(const QSizeF &, const QPointF &, Qt::Edges) const>(30, 2, QMC::AccessPublic, 0x80000000 | 31, {{
            { 0x80000000 | 32, 33 }, { 0x80000000 | 34, 35 }, { 0x80000000 | 11, 12 },
        }}),
        // Method 'sendConfigure'
        QtMocHelpers::MethodData<uint(const QSize &, const QList<int> &)>(36, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 31, 33 }, { 0x80000000 | 37, 38 },
        }}),
        // Method 'sendClose'
        QtMocHelpers::MethodData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'sendMaximized'
        QtMocHelpers::MethodData<uint(const QSize &)>(40, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 31, 33 },
        }}),
        // Method 'sendUnmaximized'
        QtMocHelpers::MethodData<uint(const QSize &)>(41, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 31, 33 },
        }}),
        // Method 'sendUnmaximized'
        QtMocHelpers::MethodData<uint()>(41, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::UInt),
        // Method 'sendFullscreen'
        QtMocHelpers::MethodData<uint(const QSize &)>(42, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 31, 33 },
        }}),
        // Method 'sendResizing'
        QtMocHelpers::MethodData<uint(const QSize &)>(43, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 31, 33 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'xdgSurface'
        QtMocHelpers::PropertyData<QWaylandXdgSurface*>(44, 0x80000000 | 45, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'parentToplevel'
        QtMocHelpers::PropertyData<QWaylandXdgToplevel*>(46, 0x80000000 | 47, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'title'
        QtMocHelpers::PropertyData<QString>(48, QMetaType::QString, QMC::DefaultPropertyFlags, 1),
        // property 'appId'
        QtMocHelpers::PropertyData<QString>(49, QMetaType::QString, QMC::DefaultPropertyFlags, 2),
        // property 'maxSize'
        QtMocHelpers::PropertyData<QSize>(50, 0x80000000 | 31, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 3),
        // property 'minSize'
        QtMocHelpers::PropertyData<QSize>(51, 0x80000000 | 31, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 4),
        // property 'states'
        QtMocHelpers::PropertyData<QList<int>>(38, 0x80000000 | 37, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
        // property 'maximized'
        QtMocHelpers::PropertyData<bool>(52, QMetaType::Bool, QMC::DefaultPropertyFlags, 8),
        // property 'fullscreen'
        QtMocHelpers::PropertyData<bool>(53, QMetaType::Bool, QMC::DefaultPropertyFlags, 9),
        // property 'resizing'
        QtMocHelpers::PropertyData<bool>(54, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'activated'
        QtMocHelpers::PropertyData<bool>(55, QMetaType::Bool, QMC::DefaultPropertyFlags, 11),
        // property 'modal'
        QtMocHelpers::PropertyData<bool>(56, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 19, 0x608),
        // property 'decorationMode'
        QtMocHelpers::PropertyData<enum DecorationMode>(57, 0x80000000 | 58, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 18),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'State'
        QtMocHelpers::EnumData<enum State>(59, 59, QMC::EnumFlags{}).add({
            {   60, State::MaximizedState },
            {   61, State::FullscreenState },
            {   62, State::ResizingState },
            {   63, State::ActivatedState },
        }),
        // enum 'DecorationMode'
        QtMocHelpers::EnumData<enum DecorationMode>(58, 58, QMC::EnumFlags{}).add({
            {   64, DecorationMode::ClientSideDecoration },
            {   65, DecorationMode::ServerSideDecoration },
        }),
    };
    return QtMocHelpers::metaObjectData<QWaylandXdgToplevel, qt_meta_tag_ZN19QWaylandXdgToplevelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QWaylandXdgToplevel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QWaylandXdgToplevelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QWaylandXdgToplevelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QWaylandXdgToplevelE_t>.metaTypes,
    nullptr
} };

void QWaylandXdgToplevel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QWaylandXdgToplevel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->parentToplevelChanged(); break;
        case 1: _t->titleChanged(); break;
        case 2: _t->appIdChanged(); break;
        case 3: _t->maxSizeChanged(); break;
        case 4: _t->minSizeChanged(); break;
        case 5: _t->startMove((*reinterpret_cast<std::add_pointer_t<QWaylandSeat*>>(_a[1]))); break;
        case 6: _t->startResize((*reinterpret_cast<std::add_pointer_t<QWaylandSeat*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Qt::Edges>>(_a[2]))); break;
        case 7: _t->statesChanged(); break;
        case 8: _t->maximizedChanged(); break;
        case 9: _t->fullscreenChanged(); break;
        case 10: _t->resizingChanged(); break;
        case 11: _t->activatedChanged(); break;
        case 12: _t->showWindowMenu((*reinterpret_cast<std::add_pointer_t<QWaylandSeat*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[2]))); break;
        case 13: _t->setMaximized(); break;
        case 14: _t->unsetMaximized(); break;
        case 15: _t->setFullscreen((*reinterpret_cast<std::add_pointer_t<QWaylandOutput*>>(_a[1]))); break;
        case 16: _t->unsetFullscreen(); break;
        case 17: _t->setMinimized(); break;
        case 18: _t->decorationModeChanged(); break;
        case 19: _t->modalChanged(); break;
        case 20: { QSize _r = _t->sizeForResize((*reinterpret_cast<std::add_pointer_t<QSizeF>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Qt::Edges>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSize*>(_a[0]) = std::move(_r); }  break;
        case 21: { uint _r = _t->sendConfigure((*reinterpret_cast<std::add_pointer_t<QSize>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[2])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 22: _t->sendClose(); break;
        case 23: { uint _r = _t->sendMaximized((*reinterpret_cast<std::add_pointer_t<QSize>>(_a[1])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 24: { uint _r = _t->sendUnmaximized((*reinterpret_cast<std::add_pointer_t<QSize>>(_a[1])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 25: { uint _r = _t->sendUnmaximized();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 26: { uint _r = _t->sendFullscreen((*reinterpret_cast<std::add_pointer_t<QSize>>(_a[1])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 27: { uint _r = _t->sendResizing((*reinterpret_cast<std::add_pointer_t<QSize>>(_a[1])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::parentToplevelChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::titleChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::appIdChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::maxSizeChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::minSizeChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)(QWaylandSeat * )>(_a, &QWaylandXdgToplevel::startMove, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)(QWaylandSeat * , Qt::Edges )>(_a, &QWaylandXdgToplevel::startResize, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::statesChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::maximizedChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::fullscreenChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::resizingChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::activatedChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)(QWaylandSeat * , const QPoint & )>(_a, &QWaylandXdgToplevel::showWindowMenu, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::setMaximized, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::unsetMaximized, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)(QWaylandOutput * )>(_a, &QWaylandXdgToplevel::setFullscreen, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::unsetFullscreen, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::setMinimized, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::decorationModeChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgToplevel::*)()>(_a, &QWaylandXdgToplevel::modalChanged, 19))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 6:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<int> >(); break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandXdgSurface* >(); break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandXdgToplevel* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QWaylandXdgSurface**>(_v) = _t->xdgSurface(); break;
        case 1: *reinterpret_cast<QWaylandXdgToplevel**>(_v) = _t->parentToplevel(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->title(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->appId(); break;
        case 4: *reinterpret_cast<QSize*>(_v) = _t->maxSize(); break;
        case 5: *reinterpret_cast<QSize*>(_v) = _t->minSize(); break;
        case 6: *reinterpret_cast<QList<int>*>(_v) = _t->statesAsInts(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->maximized(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->fullscreen(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->resizing(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->activated(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->isModal(); break;
        case 12: *reinterpret_cast<enum DecorationMode*>(_v) = _t->decorationMode(); break;
        default: break;
        }
    }
}

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

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

int QWaylandXdgToplevel::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 < 28)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 28;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 28)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 28;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 13;
    }
    return _id;
}

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

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

// SIGNAL 2
void QWaylandXdgToplevel::appIdChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void QWaylandXdgToplevel::maxSizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void QWaylandXdgToplevel::minSizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void QWaylandXdgToplevel::startMove(QWaylandSeat * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void QWaylandXdgToplevel::startResize(QWaylandSeat * _t1, Qt::Edges _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void QWaylandXdgToplevel::statesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void QWaylandXdgToplevel::maximizedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void QWaylandXdgToplevel::fullscreenChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void QWaylandXdgToplevel::resizingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void QWaylandXdgToplevel::activatedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void QWaylandXdgToplevel::showWindowMenu(QWaylandSeat * _t1, const QPoint & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void QWaylandXdgToplevel::setMaximized()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void QWaylandXdgToplevel::unsetMaximized()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void QWaylandXdgToplevel::setFullscreen(QWaylandOutput * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void QWaylandXdgToplevel::unsetFullscreen()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void QWaylandXdgToplevel::setMinimized()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void QWaylandXdgToplevel::decorationModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void QWaylandXdgToplevel::modalChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}
namespace {
struct qt_meta_tag_ZN16QWaylandXdgPopupE_t {};
} // unnamed namespace

template <> constexpr inline auto QWaylandXdgPopup::qt_create_metaobjectdata<qt_meta_tag_ZN16QWaylandXdgPopupE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QWaylandXdgPopup",
        "configuredGeometryChanged",
        "",
        "sendConfigure",
        "QRect",
        "geometry",
        "sendPopupDone",
        "xdgSurface",
        "QWaylandXdgSurface*",
        "parentXdgSurface",
        "configuredGeometry",
        "anchorRect",
        "anchorEdges",
        "Qt::Edges",
        "gravityEdges",
        "slideConstraints",
        "Qt::Orientations",
        "flipConstraints",
        "resizeConstraints",
        "offset",
        "QPoint",
        "positionerSize",
        "QSize",
        "unconstrainedPosition"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'configuredGeometryChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'sendConfigure'
        QtMocHelpers::MethodData<uint(const QRect &)>(3, 2, QMC::AccessPublic, QMetaType::UInt, {{
            { 0x80000000 | 4, 5 },
        }}),
        // Method 'sendPopupDone'
        QtMocHelpers::RevisionedMethodData<void()>(6, 2, QMC::AccessPublic, 0x10e, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'xdgSurface'
        QtMocHelpers::PropertyData<QWaylandXdgSurface*>(7, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'parentXdgSurface'
        QtMocHelpers::PropertyData<QWaylandXdgSurface*>(9, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'configuredGeometry'
        QtMocHelpers::PropertyData<QRect>(10, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'anchorRect'
        QtMocHelpers::PropertyData<QRect>(11, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'anchorEdges'
        QtMocHelpers::PropertyData<Qt::Edges>(12, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'gravityEdges'
        QtMocHelpers::PropertyData<Qt::Edges>(14, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'slideConstraints'
        QtMocHelpers::PropertyData<Qt::Orientations>(15, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'flipConstraints'
        QtMocHelpers::PropertyData<Qt::Orientations>(17, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'resizeConstraints'
        QtMocHelpers::PropertyData<Qt::Orientations>(18, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'offset'
        QtMocHelpers::PropertyData<QPoint>(19, 0x80000000 | 20, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'positionerSize'
        QtMocHelpers::PropertyData<QSize>(21, 0x80000000 | 22, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'unconstrainedPosition'
        QtMocHelpers::PropertyData<QPoint>(23, 0x80000000 | 20, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QWaylandXdgPopup, qt_meta_tag_ZN16QWaylandXdgPopupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QWaylandXdgPopup::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QWaylandXdgPopupE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QWaylandXdgPopupE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QWaylandXdgPopupE_t>.metaTypes,
    nullptr
} };

void QWaylandXdgPopup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QWaylandXdgPopup *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->configuredGeometryChanged(); break;
        case 1: { uint _r = _t->sendConfigure((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->sendPopupDone(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QWaylandXdgPopup::*)()>(_a, &QWaylandXdgPopup::configuredGeometryChanged, 0))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandXdgSurface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QWaylandXdgSurface**>(_v) = _t->xdgSurface(); break;
        case 1: *reinterpret_cast<QWaylandXdgSurface**>(_v) = _t->parentXdgSurface(); break;
        case 2: *reinterpret_cast<QRect*>(_v) = _t->configuredGeometry(); break;
        case 3: *reinterpret_cast<QRect*>(_v) = _t->anchorRect(); break;
        case 4: *reinterpret_cast<Qt::Edges*>(_v) = _t->anchorEdges(); break;
        case 5: *reinterpret_cast<Qt::Edges*>(_v) = _t->gravityEdges(); break;
        case 6: *reinterpret_cast<Qt::Orientations*>(_v) = _t->slideConstraints(); break;
        case 7: *reinterpret_cast<Qt::Orientations*>(_v) = _t->flipConstraints(); break;
        case 8: *reinterpret_cast<Qt::Orientations*>(_v) = _t->resizeConstraints(); break;
        case 9: *reinterpret_cast<QPoint*>(_v) = _t->offset(); break;
        case 10: *reinterpret_cast<QSize*>(_v) = _t->positionerSize(); break;
        case 11: *reinterpret_cast<QPoint*>(_v) = _t->unconstrainedPosition(); break;
        default: break;
        }
    }
}

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

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

int QWaylandXdgPopup::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 12;
    }
    return _id;
}

// SIGNAL 0
void QWaylandXdgPopup::configuredGeometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
QT_WARNING_POP
