/****************************************************************************
** Meta object code from reading C++ file 'qwaylandsurface.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/compositor_api/qwaylandsurface.h"
#include "qwaylanddrag.h"
#include "qwaylandcompositor.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 'qwaylandsurface.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_ZN15QWaylandSurfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto QWaylandSurface::qt_create_metaobjectdata<qt_meta_tag_ZN15QWaylandSurfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QWaylandSurface",
        "QML.Element",
        "WaylandSurfaceBase",
        "QML.AddedInVersion",
        "256",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Cannot create instance of WaylandSurfaceBase, use WaylandSurface i"
        "nstead",
        "hasContentChanged",
        "",
        "damaged",
        "QRegion",
        "rect",
        "parentChanged",
        "QWaylandSurface*",
        "newParent",
        "oldParent",
        "childAdded",
        "child",
        "sourceGeometryChanged",
        "destinationSizeChanged",
        "bufferSizeChanged",
        "bufferScaleChanged",
        "offsetForNextFrame",
        "QPoint",
        "offset",
        "contentOrientationChanged",
        "surfaceDestroyed",
        "originChanged",
        "subsurfacePositionChanged",
        "position",
        "subsurfacePlaceAbove",
        "sibling",
        "subsurfacePlaceBelow",
        "dragStarted",
        "QWaylandDrag*",
        "drag",
        "cursorSurfaceChanged",
        "inhibitsIdleChanged",
        "isOpaqueChanged",
        "configure",
        "hasBuffer",
        "redraw",
        "updateSelection",
        "initialize",
        "QWaylandCompositor*",
        "compositor",
        "QWaylandClient*",
        "client",
        "id",
        "version",
        "destroy",
        "isDestroyed",
        "frameStarted",
        "sendFrameCallbacks",
        "sourceGeometry",
        "QRectF",
        "destinationSize",
        "QSize",
        "bufferSize",
        "bufferScale",
        "contentOrientation",
        "Qt::ScreenOrientation",
        "origin",
        "QWaylandSurface::Origin",
        "hasContent",
        "cursorSurface",
        "inhibitsIdle",
        "isOpaque",
        "Origin",
        "OriginTopLeft",
        "OriginBottomLeft"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'hasContentChanged'
        QtMocHelpers::SignalData<void()>(9, 10, QMC::AccessPublic, QMetaType::Void),
        // Signal 'damaged'
        QtMocHelpers::SignalData<void(const QRegion &)>(11, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 },
        }}),
        // Signal 'parentChanged'
        QtMocHelpers::SignalData<void(QWaylandSurface *, QWaylandSurface *)>(14, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 16 }, { 0x80000000 | 15, 17 },
        }}),
        // Signal 'childAdded'
        QtMocHelpers::SignalData<void(QWaylandSurface *)>(18, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 19 },
        }}),
        // Signal 'sourceGeometryChanged'
        QtMocHelpers::RevisionedSignalData<void()>(20, 10, QMC::AccessPublic, 0x10d, QMetaType::Void),
        // Signal 'destinationSizeChanged'
        QtMocHelpers::RevisionedSignalData<void()>(21, 10, QMC::AccessPublic, 0x10d, QMetaType::Void),
        // Signal 'bufferSizeChanged'
        QtMocHelpers::RevisionedSignalData<void()>(22, 10, QMC::AccessPublic, 0x10d, QMetaType::Void),
        // Signal 'bufferScaleChanged'
        QtMocHelpers::SignalData<void()>(23, 10, QMC::AccessPublic, QMetaType::Void),
        // Signal 'offsetForNextFrame'
        QtMocHelpers::SignalData<void(const QPoint &)>(24, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 26 },
        }}),
        // Signal 'contentOrientationChanged'
        QtMocHelpers::SignalData<void()>(27, 10, QMC::AccessPublic, QMetaType::Void),
        // Signal 'surfaceDestroyed'
        QtMocHelpers::SignalData<void()>(28, 10, QMC::AccessPublic, QMetaType::Void),
        // Signal 'originChanged'
        QtMocHelpers::SignalData<void()>(29, 10, QMC::AccessPublic, QMetaType::Void),
        // Signal 'subsurfacePositionChanged'
        QtMocHelpers::SignalData<void(const QPoint &)>(30, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 31 },
        }}),
        // Signal 'subsurfacePlaceAbove'
        QtMocHelpers::SignalData<void(QWaylandSurface *)>(32, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 33 },
        }}),
        // Signal 'subsurfacePlaceBelow'
        QtMocHelpers::SignalData<void(QWaylandSurface *)>(34, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 33 },
        }}),
        // Signal 'dragStarted'
        QtMocHelpers::SignalData<void(QWaylandDrag *)>(35, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 36, 37 },
        }}),
        // Signal 'cursorSurfaceChanged'
        QtMocHelpers::SignalData<void()>(38, 10, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inhibitsIdleChanged'
        QtMocHelpers::RevisionedSignalData<void()>(39, 10, QMC::AccessPublic, 0xff0e, QMetaType::Void),
        // Signal 'isOpaqueChanged'
        QtMocHelpers::RevisionedSignalData<void()>(40, 10, QMC::AccessPublic, 0x604, QMetaType::Void),
        // Signal 'configure'
        QtMocHelpers::SignalData<void(bool)>(41, 10, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 42 },
        }}),
        // Signal 'redraw'
        QtMocHelpers::SignalData<void()>(43, 10, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateSelection'
        QtMocHelpers::SlotData<void()>(44, 10, QMC::AccessPublic, QMetaType::Void),
        // Method 'initialize'
        QtMocHelpers::MethodData<void(QWaylandCompositor *, QWaylandClient *, uint, int)>(45, 10, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 }, { 0x80000000 | 48, 49 }, { QMetaType::UInt, 50 }, { QMetaType::Int, 51 },
        }}),
        // Method 'destroy'
        QtMocHelpers::MethodData<void()>(52, 10, QMC::AccessPublic, QMetaType::Void),
        // Method 'isDestroyed'
        QtMocHelpers::MethodData<bool() const>(53, 10, QMC::AccessPublic, QMetaType::Bool),
        // Method 'frameStarted'
        QtMocHelpers::MethodData<void()>(54, 10, QMC::AccessPublic, QMetaType::Void),
        // Method 'sendFrameCallbacks'
        QtMocHelpers::MethodData<void()>(55, 10, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'client'
        QtMocHelpers::PropertyData<QWaylandClient*>(49, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'sourceGeometry'
        QtMocHelpers::PropertyData<QRectF>(56, 0x80000000 | 57, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 4, 0x10d),
        // property 'destinationSize'
        QtMocHelpers::PropertyData<QSize>(58, 0x80000000 | 59, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5, 0x10d),
        // property 'bufferSize'
        QtMocHelpers::PropertyData<QSize>(60, 0x80000000 | 59, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 6, 0x10d),
        // property 'bufferScale'
        QtMocHelpers::PropertyData<int>(61, QMetaType::Int, QMC::DefaultPropertyFlags, 7),
        // property 'contentOrientation'
        QtMocHelpers::PropertyData<Qt::ScreenOrientation>(62, 0x80000000 | 63, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 9),
        // property 'origin'
        QtMocHelpers::PropertyData<QWaylandSurface::Origin>(64, 0x80000000 | 65, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 11),
        // property 'hasContent'
        QtMocHelpers::PropertyData<bool>(66, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'cursorSurface'
        QtMocHelpers::PropertyData<bool>(67, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 16),
        // property 'inhibitsIdle'
        QtMocHelpers::PropertyData<bool>(68, QMetaType::Bool, QMC::DefaultPropertyFlags, 17, 0x10e),
        // property 'isOpaque'
        QtMocHelpers::PropertyData<bool>(69, QMetaType::Bool, QMC::DefaultPropertyFlags, 18, 0x604),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Origin'
        QtMocHelpers::EnumData<enum Origin>(70, 70, QMC::EnumFlags{}).add({
            {   71, Origin::OriginTopLeft },
            {   72, Origin::OriginBottomLeft },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<QWaylandSurface, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QWaylandSurface::staticMetaObject = { {
    QMetaObject::SuperData::link<QWaylandObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QWaylandSurfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QWaylandSurfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15QWaylandSurfaceE_t>.metaTypes,
    nullptr
} };

void QWaylandSurface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QWaylandSurface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->hasContentChanged(); break;
        case 1: _t->damaged((*reinterpret_cast<std::add_pointer_t<QRegion>>(_a[1]))); break;
        case 2: _t->parentChanged((*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[2]))); break;
        case 3: _t->childAdded((*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[1]))); break;
        case 4: _t->sourceGeometryChanged(); break;
        case 5: _t->destinationSizeChanged(); break;
        case 6: _t->bufferSizeChanged(); break;
        case 7: _t->bufferScaleChanged(); break;
        case 8: _t->offsetForNextFrame((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 9: _t->contentOrientationChanged(); break;
        case 10: _t->surfaceDestroyed(); break;
        case 11: _t->originChanged(); break;
        case 12: _t->subsurfacePositionChanged((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 13: _t->subsurfacePlaceAbove((*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[1]))); break;
        case 14: _t->subsurfacePlaceBelow((*reinterpret_cast<std::add_pointer_t<QWaylandSurface*>>(_a[1]))); break;
        case 15: _t->dragStarted((*reinterpret_cast<std::add_pointer_t<QWaylandDrag*>>(_a[1]))); break;
        case 16: _t->cursorSurfaceChanged(); break;
        case 17: _t->inhibitsIdleChanged(); break;
        case 18: _t->isOpaqueChanged(); break;
        case 19: _t->configure((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->redraw(); break;
        case 21: _t->updateSelection(); break;
        case 22: _t->initialize((*reinterpret_cast<std::add_pointer_t<QWaylandCompositor*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWaylandClient*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<uint>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 23: _t->destroy(); break;
        case 24: { bool _r = _t->isDestroyed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 25: _t->frameStarted(); break;
        case 26: _t->sendFrameCallbacks(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandSurface* >(); 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< QWaylandSurface* >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandSurface* >(); break;
            }
            break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandSurface* >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandDrag* >(); break;
            }
            break;
        case 22:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandClient* >(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWaylandCompositor* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::hasContentChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(const QRegion & )>(_a, &QWaylandSurface::damaged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(QWaylandSurface * , QWaylandSurface * )>(_a, &QWaylandSurface::parentChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(QWaylandSurface * )>(_a, &QWaylandSurface::childAdded, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::sourceGeometryChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::destinationSizeChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::bufferSizeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::bufferScaleChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(const QPoint & )>(_a, &QWaylandSurface::offsetForNextFrame, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::contentOrientationChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::surfaceDestroyed, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::originChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(const QPoint & )>(_a, &QWaylandSurface::subsurfacePositionChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(QWaylandSurface * )>(_a, &QWaylandSurface::subsurfacePlaceAbove, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(QWaylandSurface * )>(_a, &QWaylandSurface::subsurfacePlaceBelow, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(QWaylandDrag * )>(_a, &QWaylandSurface::dragStarted, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::cursorSurfaceChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::inhibitsIdleChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::isOpaqueChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)(bool )>(_a, &QWaylandSurface::configure, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (QWaylandSurface::*)()>(_a, &QWaylandSurface::redraw, 20))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWaylandClient* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QWaylandClient**>(_v) = _t->client(); break;
        case 1: *reinterpret_cast<QRectF*>(_v) = _t->sourceGeometry(); break;
        case 2: *reinterpret_cast<QSize*>(_v) = _t->destinationSize(); break;
        case 3: *reinterpret_cast<QSize*>(_v) = _t->bufferSize(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->bufferScale(); break;
        case 5: *reinterpret_cast<Qt::ScreenOrientation*>(_v) = _t->contentOrientation(); break;
        case 6: *reinterpret_cast<QWaylandSurface::Origin*>(_v) = _t->origin(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->hasContent(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->isCursorSurface(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->inhibitsIdle(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isOpaque(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 8: _t->markAsCursorSurface(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QWaylandSurface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWaylandObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 27)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 27;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 27)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 27;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    return _id;
}

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

// SIGNAL 1
void QWaylandSurface::damaged(const QRegion & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void QWaylandSurface::parentChanged(QWaylandSurface * _t1, QWaylandSurface * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

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

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

// SIGNAL 5
void QWaylandSurface::destinationSizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

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

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

// SIGNAL 8
void QWaylandSurface::offsetForNextFrame(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

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

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

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

// SIGNAL 12
void QWaylandSurface::subsurfacePositionChanged(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void QWaylandSurface::subsurfacePlaceAbove(QWaylandSurface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void QWaylandSurface::subsurfacePlaceBelow(QWaylandSurface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void QWaylandSurface::dragStarted(QWaylandDrag * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

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

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

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

// SIGNAL 19
void QWaylandSurface::configure(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void QWaylandSurface::redraw()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}
QT_WARNING_POP
