/****************************************************************************
** Meta object code from reading C++ file 'buttonexample.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 "../../../../../examples/collections/buttonexample.h"
#include <QtGui/qtextcursor.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 'buttonexample.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_ZN19ButtonExampleWindowE_t {};
} // unnamed namespace

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

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

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

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

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

int ButtonExampleWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PageWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18DPushButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DPushButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21DWarningButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DWarningButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21DSuggestButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DSuggestButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18DToolButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DToolButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18DIconButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DIconButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17DButtonBoxExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DButtonBoxExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN22DFloatingButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DFloatingButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20DSwitchButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DSwitchButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19DRadioButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DRadioButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19DCheckButtonExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DCheckButtonExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16DComboBoxExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DComboBoxExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20DFontComboBoxExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DFontComboBoxExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN22DSearchComboBoxExampleE_t {};
} // unnamed namespace

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

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

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

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

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

int DSearchComboBoxExample::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ExampleWindowInterface::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
