/****************************************************************************
** Meta object code from reading C++ file 'capture.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/capture/capture.h"
#include "woutput.h"
#include <wsurface.h>
#include <woutput.h>
#include <output/output.h>
#include "core/rootsurfacecontainer.h"
#include "wcursor.h"
#include "private/wserver_p.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 'capture.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_ZN13CaptureSourceE_t {};
} // unnamed namespace

template <> constexpr inline auto CaptureSource::qt_create_metaobjectdata<qt_meta_tag_ZN13CaptureSourceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CaptureSource",
        "imageReady",
        "",
        "bufferDestroyed",
        "targetDestroyed",
        "targetResized",
        "CaptureSourceType",
        "Output",
        "Window",
        "Region",
        "Surface"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'imageReady'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'bufferDestroyed'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'targetDestroyed'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'targetResized'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'CaptureSourceType'
        QtMocHelpers::EnumData<enum CaptureSourceType>(6, 6, QMC::EnumFlags{}).add({
            {    7, CaptureSourceType::Output },
            {    8, CaptureSourceType::Window },
            {    9, CaptureSourceType::Region },
            {   10, CaptureSourceType::Surface },
        }),
    };
    return QtMocHelpers::metaObjectData<CaptureSource, qt_meta_tag_ZN13CaptureSourceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CaptureSource::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CaptureSourceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13CaptureSourceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13CaptureSourceE_t>.metaTypes,
    nullptr
} };

void CaptureSource::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CaptureSource *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->imageReady(); break;
        case 1: _t->bufferDestroyed(); break;
        case 2: _t->targetDestroyed(); break;
        case 3: _t->targetResized(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CaptureSource::*)()>(_a, &CaptureSource::imageReady, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSource::*)()>(_a, &CaptureSource::bufferDestroyed, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSource::*)()>(_a, &CaptureSource::targetDestroyed, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSource::*)()>(_a, &CaptureSource::targetResized, 3))
            return;
    }
}

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

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

int CaptureSource::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 < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 4;
    }
    return _id;
}

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

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

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

// SIGNAL 3
void CaptureSource::targetResized()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}
namespace {
struct qt_meta_tag_ZN19CaptureContextModelE_t {};
} // unnamed namespace

template <> constexpr inline auto CaptureContextModel::qt_create_metaobjectdata<qt_meta_tag_ZN19CaptureContextModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CaptureContextModel",
        "CaptureContextRole",
        "ContextRole"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'CaptureContextRole'
        QtMocHelpers::EnumData<enum CaptureContextRole>(1, 1, QMC::EnumFlags{}).add({
            {    2, CaptureContextRole::ContextRole },
        }),
    };
    return QtMocHelpers::metaObjectData<CaptureContextModel, qt_meta_tag_ZN19CaptureContextModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CaptureContextModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19CaptureContextModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19CaptureContextModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19CaptureContextModelE_t>.metaTypes,
    nullptr
} };

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

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

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

int CaptureContextModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16CaptureContextV1E_t {};
} // unnamed namespace

template <> constexpr inline auto CaptureContextV1::qt_create_metaobjectdata<qt_meta_tag_ZN16CaptureContextV1E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CaptureContextV1",
        "sourceChanged",
        "",
        "finishSelect",
        "selectInfoReady",
        "mask",
        "WSurface*",
        "freeze",
        "withCursor",
        "sourceHint",
        "CaptureSource::CaptureSourceHint",
        "SourceFailure",
        "SelectorBusy",
        "UserCancel",
        "SourceDestroyed",
        "Other"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'sourceChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'finishSelect'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectInfoReady'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'mask'
        QtMocHelpers::PropertyData<WSurface*>(5, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Final, 2),
        // property 'freeze'
        QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 2),
        // property 'withCursor'
        QtMocHelpers::PropertyData<bool>(8, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Final, 2),
        // property 'sourceHint'
        QtMocHelpers::PropertyData<CaptureSource::CaptureSourceHint>(9, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Final, 2),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'SourceFailure'
        QtMocHelpers::EnumData<enum SourceFailure>(11, 11, QMC::EnumFlags{}).add({
            {   12, SourceFailure::SelectorBusy },
            {   13, SourceFailure::UserCancel },
            {   14, SourceFailure::SourceDestroyed },
            {   15, SourceFailure::Other },
        }),
    };
    return QtMocHelpers::metaObjectData<CaptureContextV1, qt_meta_tag_ZN16CaptureContextV1E_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN16CaptureContextV1E[] = {
    QMetaObject::SuperData::link<CaptureSource::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject CaptureContextV1::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16CaptureContextV1E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16CaptureContextV1E_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN16CaptureContextV1E,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16CaptureContextV1E_t>.metaTypes,
    nullptr
} };

void CaptureContextV1::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CaptureContextV1 *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->sourceChanged(); break;
        case 1: _t->finishSelect(); break;
        case 2: _t->selectInfoReady(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CaptureContextV1::*)()>(_a, &CaptureContextV1::sourceChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureContextV1::*)()>(_a, &CaptureContextV1::finishSelect, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureContextV1::*)()>(_a, &CaptureContextV1::selectInfoReady, 2))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< WSurface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<WSurface**>(_v) = _t->mask(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->freeze(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->withCursor(); break;
        case 3: *reinterpret_cast<CaptureSource::CaptureSourceHint*>(_v) = _t->sourceHint(); break;
        default: break;
        }
    }
}

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

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

int CaptureContextV1::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 -= 4;
    }
    return _id;
}

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

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

// SIGNAL 2
void CaptureContextV1::selectInfoReady()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN16CaptureManagerV1E_t {};
} // unnamed namespace

template <> constexpr inline auto CaptureManagerV1::qt_create_metaobjectdata<qt_meta_tag_ZN16CaptureManagerV1E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CaptureManagerV1",
        "contextInSelectionChanged",
        "",
        "newCaptureContext",
        "CaptureContextV1*",
        "context",
        "selectorChanged",
        "onCaptureContextSelectSource",
        "freezeAllCapturedSurface",
        "freeze",
        "Waylib::Server::WSurface*",
        "maskItem",
        "handleContextBeforeDestroy",
        "contextInSelection"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'contextInSelectionChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newCaptureContext'
        QtMocHelpers::SignalData<void(CaptureContextV1 *)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 4, 5 },
        }}),
        // Signal 'selectorChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onCaptureContextSelectSource'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'freezeAllCapturedSurface'
        QtMocHelpers::SlotData<void(bool, Waylib::Server::WSurface *)>(8, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 9 }, { 0x80000000 | 10, 11 },
        }}),
        // Slot 'handleContextBeforeDestroy'
        QtMocHelpers::SlotData<void(CaptureContextV1 *)>(12, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 4, 5 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'contextInSelection'
        QtMocHelpers::PropertyData<CaptureContextV1*>(13, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Final, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CaptureManagerV1, qt_meta_tag_ZN16CaptureManagerV1E_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CaptureManagerV1::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16CaptureManagerV1E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16CaptureManagerV1E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16CaptureManagerV1E_t>.metaTypes,
    nullptr
} };

void CaptureManagerV1::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CaptureManagerV1 *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->contextInSelectionChanged(); break;
        case 1: _t->newCaptureContext((*reinterpret_cast<std::add_pointer_t<CaptureContextV1*>>(_a[1]))); break;
        case 2: _t->selectorChanged(); break;
        case 3: _t->onCaptureContextSelectSource(); break;
        case 4: _t->freezeAllCapturedSurface((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Waylib::Server::WSurface*>>(_a[2]))); break;
        case 5: _t->handleContextBeforeDestroy((*reinterpret_cast<std::add_pointer_t<CaptureContextV1*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); 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< CaptureContextV1* >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Waylib::Server::WSurface* >(); 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< CaptureContextV1* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CaptureManagerV1::*)()>(_a, &CaptureManagerV1::contextInSelectionChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureManagerV1::*)(CaptureContextV1 * )>(_a, &CaptureManagerV1::newCaptureContext, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureManagerV1::*)()>(_a, &CaptureManagerV1::selectorChanged, 2))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< CaptureContextV1* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<CaptureContextV1**>(_v) = _t->contextInSelection(); break;
        default: break;
        }
    }
}

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

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

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

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

// SIGNAL 1
void CaptureManagerV1::newCaptureContext(CaptureContextV1 * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void CaptureManagerV1::selectorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN20CaptureSourceSurfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int CaptureSourceSurface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CaptureSource::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19CaptureSourceOutputE_t {};
} // unnamed namespace

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

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

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

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

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

int CaptureSourceOutput::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CaptureSource::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19CaptureSourceRegionE_t {};
} // unnamed namespace

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

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

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

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

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

int CaptureSourceRegion::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CaptureSource::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21CaptureSourceSelectorE_t {};
} // unnamed namespace

template <> constexpr inline auto CaptureSourceSelector::qt_create_metaobjectdata<qt_meta_tag_ZN21CaptureSourceSelectorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CaptureSourceSelector",
        "DefaultProperty",
        "contents",
        "QML.Element",
        "auto",
        "hoveredItemChanged",
        "",
        "selectedSourceChanged",
        "captureManagerChanged",
        "selectionRegionChanged",
        "selectionModeChanged",
        "captureManager",
        "CaptureManagerV1*",
        "selectionRegion",
        "QRectF",
        "selectionMode",
        "SelectionMode",
        "QQmlListProperty<QObject>",
        "toolBarModel",
        "ToolBarModel*",
        "SelectOutput",
        "SelectWindow",
        "SelectRegion"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'hoveredItemChanged'
        QtMocHelpers::SignalData<void()>(5, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedSourceChanged'
        QtMocHelpers::SignalData<void()>(7, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'captureManagerChanged'
        QtMocHelpers::SignalData<void()>(8, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectionRegionChanged'
        QtMocHelpers::SignalData<void()>(9, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectionModeChanged'
        QtMocHelpers::SignalData<void()>(10, 6, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'captureManager'
        QtMocHelpers::PropertyData<CaptureManagerV1*>(11, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet | QMC::Final | QMC::Required, 2),
        // property 'selectionRegion'
        QtMocHelpers::PropertyData<QRectF>(13, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Final, 3),
        // property 'selectionMode'
        QtMocHelpers::PropertyData<enum SelectionMode>(15, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet | QMC::Final, 4),
        // property 'contents'
        QtMocHelpers::PropertyData<QQmlListProperty<QObject>>(2, 0x80000000 | 17, QMC::Readable | QMC::Scriptable | QMC::Stored | QMC::EnumOrFlag | QMC::Constant),
        // property 'toolBarModel'
        QtMocHelpers::PropertyData<ToolBarModel*>(18, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant | QMC::Final),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'SelectionMode'
        QtMocHelpers::EnumData<enum SelectionMode>(16, 16, QMC::EnumIsScoped).add({
            {   20, SelectionMode::SelectOutput },
            {   21, SelectionMode::SelectWindow },
            {   22, SelectionMode::SelectRegion },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<CaptureSourceSelector, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject CaptureSourceSelector::staticMetaObject = { {
    QMetaObject::SuperData::link<SurfaceContainer::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21CaptureSourceSelectorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21CaptureSourceSelectorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21CaptureSourceSelectorE_t>.metaTypes,
    nullptr
} };

void CaptureSourceSelector::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CaptureSourceSelector *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->hoveredItemChanged(); break;
        case 1: _t->selectedSourceChanged(); break;
        case 2: _t->captureManagerChanged(); break;
        case 3: _t->selectionRegionChanged(); break;
        case 4: _t->selectionModeChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CaptureSourceSelector::*)()>(_a, &CaptureSourceSelector::hoveredItemChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSourceSelector::*)()>(_a, &CaptureSourceSelector::selectedSourceChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSourceSelector::*)()>(_a, &CaptureSourceSelector::captureManagerChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSourceSelector::*)()>(_a, &CaptureSourceSelector::selectionRegionChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureSourceSelector::*)()>(_a, &CaptureSourceSelector::selectionModeChanged, 4))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< CaptureManagerV1* >(); break;
        case 4:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ToolBarModel* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<CaptureManagerV1**>(_v) = _t->captureManager(); break;
        case 1: *reinterpret_cast<QRectF*>(_v) = _t->selectionRegion(); break;
        case 2: *reinterpret_cast<enum SelectionMode*>(_v) = _t->selectionMode(); break;
        case 3: *reinterpret_cast<QQmlListProperty<QObject>*>(_v) = _t->contents(); break;
        case 4: *reinterpret_cast<ToolBarModel**>(_v) = _t->toolBarModel(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setCaptureManager(*reinterpret_cast<CaptureManagerV1**>(_v)); break;
        case 2: _t->setSelectionMode(*reinterpret_cast<enum SelectionMode*>(_v)); break;
        default: break;
        }
    }
}

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

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

int CaptureSourceSelector::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = SurfaceContainer::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    return _id;
}

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

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

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

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

// SIGNAL 4
void CaptureSourceSelector::selectionModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}
namespace {
struct qt_meta_tag_ZN12ToolBarModelE_t {};
} // unnamed namespace

template <> constexpr inline auto ToolBarModel::qt_create_metaobjectdata<qt_meta_tag_ZN12ToolBarModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ToolBarModel",
        "countChanged",
        "",
        "count",
        "ToolBarRole",
        "IconNameRole",
        "SelectionModeRole"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'countChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'count'
        QtMocHelpers::PropertyData<uint>(3, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Final, 0),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ToolBarRole'
        QtMocHelpers::EnumData<enum ToolBarRole>(4, 4, QMC::EnumFlags{}).add({
            {    5, ToolBarRole::IconNameRole },
            {    6, ToolBarRole::SelectionModeRole },
        }),
    };
    return QtMocHelpers::metaObjectData<ToolBarModel, qt_meta_tag_ZN12ToolBarModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ToolBarModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ToolBarModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ToolBarModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12ToolBarModelE_t>.metaTypes,
    nullptr
} };

void ToolBarModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ToolBarModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->countChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ToolBarModel::*)()>(_a, &ToolBarModel::countChanged, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<uint*>(_v) = _t->rowCount(); break;
        default: break;
        }
    }
}

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

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

int ToolBarModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

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