/****************************************************************************
** Meta object code from reading C++ file 'qcanvas2dbrushvaluetype_p.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 "../../../../../qtcanvaspainter/src/canvas2d/qcanvas2dbrushvaluetype_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 'qcanvas2dbrushvaluetype_p.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_ZN32QCanvas2DLinearGradientValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DLinearGradientValueType::qt_create_metaobjectdata<qt_meta_tag_ZN32QCanvas2DLinearGradientValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DLinearGradientValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasLinearGradient",
        "QML.Element",
        "lineargradient2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "addColorStop",
        "",
        "offset",
        "QColor",
        "color",
        "startPosition",
        "QPointF",
        "setStartPosition",
        "x",
        "y",
        "start",
        "endPosition",
        "setEndPosition",
        "end"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'addColorStop'
        QtMocHelpers::MethodData<void(float, const QColor &)>(12, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 14 }, { 0x80000000 | 15, 16 },
        }}),
        // Method 'startPosition'
        QtMocHelpers::MethodData<QPointF() const>(17, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setStartPosition'
        QtMocHelpers::MethodData<void(float, float)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 },
        }}),
        // Method 'setStartPosition'
        QtMocHelpers::MethodData<void(QPointF)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 22 },
        }}),
        // Method 'endPosition'
        QtMocHelpers::MethodData<QPointF() const>(23, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setEndPosition'
        QtMocHelpers::MethodData<void(float, float)>(24, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 },
        }}),
        // Method 'setEndPosition'
        QtMocHelpers::MethodData<void(QPointF)>(24, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 25 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(13, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DLinearGradientValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DLinearGradientValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasLinearGradient>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN32QCanvas2DLinearGradientValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN32QCanvas2DLinearGradientValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN32QCanvas2DLinearGradientValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DLinearGradientValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DLinearGradientValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DLinearGradientValueType *_r = new QCanvas2DLinearGradientValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DLinearGradientValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->addColorStop((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2]))); break;
        case 1: { QPointF _r = _t->startPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->setStartPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 3: _t->setStartPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 4: { QPointF _r = _t->endPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 5: _t->setEndPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 6: _t->setEndPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN32QCanvas2DRadialGradientValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DRadialGradientValueType::qt_create_metaobjectdata<qt_meta_tag_ZN32QCanvas2DRadialGradientValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DRadialGradientValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasRadialGradient",
        "QML.Element",
        "radialgradient2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "addColorStop",
        "",
        "offset",
        "QColor",
        "color",
        "centerPosition",
        "QPointF",
        "setCenterPosition",
        "x",
        "y",
        "center",
        "innerCenterPosition",
        "setInnerCenterPosition",
        "outerCenterPosition",
        "setOuterCenterPosition",
        "outerRadius",
        "setOuterRadius",
        "radius",
        "innerRadius",
        "setInnerRadius"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'addColorStop'
        QtMocHelpers::MethodData<void(float, const QColor &)>(12, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 14 }, { 0x80000000 | 15, 16 },
        }}),
        // Method 'centerPosition'
        QtMocHelpers::MethodData<QPointF() const>(17, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setCenterPosition'
        QtMocHelpers::MethodData<void(float, float)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 },
        }}),
        // Method 'setCenterPosition'
        QtMocHelpers::MethodData<void(QPointF)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 22 },
        }}),
        // Method 'innerCenterPosition'
        QtMocHelpers::MethodData<QPointF() const>(23, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setInnerCenterPosition'
        QtMocHelpers::MethodData<void(float, float)>(24, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 },
        }}),
        // Method 'setInnerCenterPosition'
        QtMocHelpers::MethodData<void(QPointF)>(24, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 22 },
        }}),
        // Method 'outerCenterPosition'
        QtMocHelpers::MethodData<QPointF() const>(25, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setOuterCenterPosition'
        QtMocHelpers::MethodData<void(float, float)>(26, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 },
        }}),
        // Method 'setOuterCenterPosition'
        QtMocHelpers::MethodData<void(QPointF)>(26, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 22 },
        }}),
        // Method 'outerRadius'
        QtMocHelpers::MethodData<float() const>(27, 13, QMC::AccessPublic, QMetaType::Float),
        // Method 'setOuterRadius'
        QtMocHelpers::MethodData<void(float)>(28, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 29 },
        }}),
        // Method 'innerRadius'
        QtMocHelpers::MethodData<float() const>(30, 13, QMC::AccessPublic, QMetaType::Float),
        // Method 'setInnerRadius'
        QtMocHelpers::MethodData<void(float)>(31, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 29 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(13, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DRadialGradientValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DRadialGradientValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasRadialGradient>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN32QCanvas2DRadialGradientValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN32QCanvas2DRadialGradientValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN32QCanvas2DRadialGradientValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DRadialGradientValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DRadialGradientValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DRadialGradientValueType *_r = new QCanvas2DRadialGradientValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DRadialGradientValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->addColorStop((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2]))); break;
        case 1: { QPointF _r = _t->centerPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->setCenterPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 3: _t->setCenterPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 4: { QPointF _r = _t->innerCenterPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 5: _t->setInnerCenterPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 6: _t->setInnerCenterPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 7: { QPointF _r = _t->outerCenterPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 8: _t->setOuterCenterPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 9: _t->setOuterCenterPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 10: { float _r = _t->outerRadius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 11: _t->setOuterRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 12: { float _r = _t->innerRadius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 13: _t->setInnerRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN33QCanvas2DConicalGradientValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DConicalGradientValueType::qt_create_metaobjectdata<qt_meta_tag_ZN33QCanvas2DConicalGradientValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DConicalGradientValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasConicalGradient",
        "QML.Element",
        "conicalgradient2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "addColorStop",
        "",
        "offset",
        "QColor",
        "color",
        "centerPosition",
        "QPointF",
        "setCenterPosition",
        "x",
        "y",
        "center",
        "angle",
        "setAngle"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'addColorStop'
        QtMocHelpers::MethodData<void(float, const QColor &)>(12, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 14 }, { 0x80000000 | 15, 16 },
        }}),
        // Method 'centerPosition'
        QtMocHelpers::MethodData<QPointF() const>(17, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setCenterPosition'
        QtMocHelpers::MethodData<void(float, float)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 },
        }}),
        // Method 'setCenterPosition'
        QtMocHelpers::MethodData<void(QPointF)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 22 },
        }}),
        // Method 'angle'
        QtMocHelpers::MethodData<float() const>(23, 13, QMC::AccessPublic, QMetaType::Float),
        // Method 'setAngle'
        QtMocHelpers::MethodData<void(float)>(24, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 23 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(13, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DConicalGradientValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DConicalGradientValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasConicalGradient>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QCanvas2DConicalGradientValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QCanvas2DConicalGradientValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33QCanvas2DConicalGradientValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DConicalGradientValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DConicalGradientValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DConicalGradientValueType *_r = new QCanvas2DConicalGradientValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DConicalGradientValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->addColorStop((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2]))); break;
        case 1: { QPointF _r = _t->centerPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->setCenterPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 3: _t->setCenterPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 4: { float _r = _t->angle();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 5: _t->setAngle((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN29QCanvas2DBoxGradientValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DBoxGradientValueType::qt_create_metaobjectdata<qt_meta_tag_ZN29QCanvas2DBoxGradientValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DBoxGradientValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasBoxGradient",
        "QML.Element",
        "boxgradient2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "addColorStop",
        "",
        "offset",
        "QColor",
        "color",
        "rect",
        "QRectF",
        "setRect",
        "x",
        "y",
        "width",
        "height",
        "feather",
        "setFeather",
        "radius",
        "setRadius"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'addColorStop'
        QtMocHelpers::MethodData<void(float, const QColor &)>(12, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 14 }, { 0x80000000 | 15, 16 },
        }}),
        // Method 'rect'
        QtMocHelpers::MethodData<QRectF() const>(17, 13, QMC::AccessPublic, 0x80000000 | 18),
        // Method 'setRect'
        QtMocHelpers::MethodData<void(float, float, float, float)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 20 }, { QMetaType::Float, 21 }, { QMetaType::Float, 22 }, { QMetaType::Float, 23 },
        }}),
        // Method 'setRect'
        QtMocHelpers::MethodData<void(const QRectF &)>(19, 13, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 17 },
        }}),
        // Method 'feather'
        QtMocHelpers::MethodData<float() const>(24, 13, QMC::AccessPublic, QMetaType::Float),
        // Method 'setFeather'
        QtMocHelpers::MethodData<void(float)>(25, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 24 },
        }}),
        // Method 'radius'
        QtMocHelpers::MethodData<float() const>(26, 13, QMC::AccessPublic, QMetaType::Float),
        // Method 'setRadius'
        QtMocHelpers::MethodData<void(float)>(27, 13, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 26 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(13, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DBoxGradientValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DBoxGradientValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasBoxGradient>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29QCanvas2DBoxGradientValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29QCanvas2DBoxGradientValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29QCanvas2DBoxGradientValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DBoxGradientValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DBoxGradientValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DBoxGradientValueType *_r = new QCanvas2DBoxGradientValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DBoxGradientValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->addColorStop((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2]))); break;
        case 1: { QRectF _r = _t->rect();
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 2: _t->setRect((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[4]))); break;
        case 3: _t->setRect((*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[1]))); break;
        case 4: { float _r = _t->feather();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 5: _t->setFeather((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 6: { float _r = _t->radius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->setRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN29QCanvas2DGridPatternValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DGridPatternValueType::qt_create_metaobjectdata<qt_meta_tag_ZN29QCanvas2DGridPatternValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DGridPatternValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasGridPattern",
        "QML.Element",
        "gridpattern2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "startPosition",
        "QPointF",
        "",
        "setStartPosition",
        "x",
        "y",
        "point",
        "cellSize",
        "QSizeF",
        "setCellSize",
        "width",
        "height",
        "size",
        "lineWidth",
        "setLineWidth",
        "feather",
        "setFeather",
        "rotation",
        "setRotation",
        "lineColor",
        "QColor",
        "setLineColor",
        "color",
        "backgroundColor",
        "setBackgroundColor"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'startPosition'
        QtMocHelpers::MethodData<QPointF() const>(12, 14, QMC::AccessPublic, 0x80000000 | 13),
        // Method 'setStartPosition'
        QtMocHelpers::MethodData<void(float, float)>(15, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 16 }, { QMetaType::Float, 17 },
        }}),
        // Method 'setStartPosition'
        QtMocHelpers::MethodData<void(QPointF)>(15, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 18 },
        }}),
        // Method 'cellSize'
        QtMocHelpers::MethodData<QSizeF() const>(19, 14, QMC::AccessPublic, 0x80000000 | 20),
        // Method 'setCellSize'
        QtMocHelpers::MethodData<void(float, float)>(21, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 22 }, { QMetaType::Float, 23 },
        }}),
        // Method 'setCellSize'
        QtMocHelpers::MethodData<void(QSizeF)>(21, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 24 },
        }}),
        // Method 'lineWidth'
        QtMocHelpers::MethodData<float() const>(25, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setLineWidth'
        QtMocHelpers::MethodData<void(float)>(26, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 22 },
        }}),
        // Method 'feather'
        QtMocHelpers::MethodData<float() const>(27, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setFeather'
        QtMocHelpers::MethodData<void(float)>(28, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 27 },
        }}),
        // Method 'rotation'
        QtMocHelpers::MethodData<float() const>(29, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setRotation'
        QtMocHelpers::MethodData<void(float)>(30, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 29 },
        }}),
        // Method 'lineColor'
        QtMocHelpers::MethodData<QColor() const>(31, 14, QMC::AccessPublic, 0x80000000 | 32),
        // Method 'setLineColor'
        QtMocHelpers::MethodData<void(const QColor &)>(33, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 34 },
        }}),
        // Method 'backgroundColor'
        QtMocHelpers::MethodData<QColor() const>(35, 14, QMC::AccessPublic, 0x80000000 | 32),
        // Method 'setBackgroundColor'
        QtMocHelpers::MethodData<void(const QColor &)>(36, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 34 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(14, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DGridPatternValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DGridPatternValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasGridPattern>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29QCanvas2DGridPatternValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29QCanvas2DGridPatternValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29QCanvas2DGridPatternValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DGridPatternValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DGridPatternValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DGridPatternValueType *_r = new QCanvas2DGridPatternValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DGridPatternValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QPointF _r = _t->startPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 1: _t->setStartPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 2: _t->setStartPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 3: { QSizeF _r = _t->cellSize();
            if (_a[0]) *reinterpret_cast<QSizeF*>(_a[0]) = std::move(_r); }  break;
        case 4: _t->setCellSize((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 5: _t->setCellSize((*reinterpret_cast<std::add_pointer_t<QSizeF>>(_a[1]))); break;
        case 6: { float _r = _t->lineWidth();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->setLineWidth((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 8: { float _r = _t->feather();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 9: _t->setFeather((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 10: { float _r = _t->rotation();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 11: _t->setRotation((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 12: { QColor _r = _t->lineColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 13: _t->setLineColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1]))); break;
        case 14: { QColor _r = _t->backgroundColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 15: _t->setBackgroundColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1]))); break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN27QCanvas2DBoxShadowValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DBoxShadowValueType::qt_create_metaobjectdata<qt_meta_tag_ZN27QCanvas2DBoxShadowValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DBoxShadowValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasBoxShadow",
        "QML.Element",
        "boxshadow2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "rect",
        "QRectF",
        "",
        "setRect",
        "x",
        "y",
        "width",
        "height",
        "boundingRect",
        "radius",
        "setRadius",
        "blur",
        "setBlur",
        "spread",
        "setSpread",
        "color",
        "QColor",
        "setColor",
        "topLeftRadius",
        "setTopLeftRadius",
        "topRightRadius",
        "setTopRightRadius",
        "bottomLeftRadius",
        "setBottomLeftRadius",
        "bottomRightRadius",
        "setBottomRightRadius"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'rect'
        QtMocHelpers::MethodData<QRectF() const>(12, 14, QMC::AccessPublic, 0x80000000 | 13),
        // Method 'setRect'
        QtMocHelpers::MethodData<void(const QRectF &)>(15, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 12 },
        }}),
        // Method 'setRect'
        QtMocHelpers::MethodData<void(float, float, float, float)>(15, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 16 }, { QMetaType::Float, 17 }, { QMetaType::Float, 18 }, { QMetaType::Float, 19 },
        }}),
        // Method 'boundingRect'
        QtMocHelpers::MethodData<QRectF() const>(20, 14, QMC::AccessPublic, 0x80000000 | 13),
        // Method 'radius'
        QtMocHelpers::MethodData<float() const>(21, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setRadius'
        QtMocHelpers::MethodData<void(float)>(22, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 21 },
        }}),
        // Method 'blur'
        QtMocHelpers::MethodData<float() const>(23, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setBlur'
        QtMocHelpers::MethodData<void(float)>(24, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 23 },
        }}),
        // Method 'spread'
        QtMocHelpers::MethodData<float() const>(25, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setSpread'
        QtMocHelpers::MethodData<void(float)>(26, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 25 },
        }}),
        // Method 'color'
        QtMocHelpers::MethodData<QColor() const>(27, 14, QMC::AccessPublic, 0x80000000 | 28),
        // Method 'setColor'
        QtMocHelpers::MethodData<void(const QColor &)>(29, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 27 },
        }}),
        // Method 'topLeftRadius'
        QtMocHelpers::MethodData<float() const>(30, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setTopLeftRadius'
        QtMocHelpers::MethodData<void(float)>(31, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 21 },
        }}),
        // Method 'topRightRadius'
        QtMocHelpers::MethodData<float() const>(32, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setTopRightRadius'
        QtMocHelpers::MethodData<void(float)>(33, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 21 },
        }}),
        // Method 'bottomLeftRadius'
        QtMocHelpers::MethodData<float() const>(34, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setBottomLeftRadius'
        QtMocHelpers::MethodData<void(float)>(35, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 21 },
        }}),
        // Method 'bottomRightRadius'
        QtMocHelpers::MethodData<float() const>(36, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setBottomRightRadius'
        QtMocHelpers::MethodData<void(float)>(37, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 21 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(14, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DBoxShadowValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DBoxShadowValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasBoxShadow>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QCanvas2DBoxShadowValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QCanvas2DBoxShadowValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27QCanvas2DBoxShadowValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DBoxShadowValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DBoxShadowValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DBoxShadowValueType *_r = new QCanvas2DBoxShadowValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DBoxShadowValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QRectF _r = _t->rect();
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 1: _t->setRect((*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[1]))); break;
        case 2: _t->setRect((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[4]))); break;
        case 3: { QRectF _r = _t->boundingRect();
            if (_a[0]) *reinterpret_cast<QRectF*>(_a[0]) = std::move(_r); }  break;
        case 4: { float _r = _t->radius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 5: _t->setRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 6: { float _r = _t->blur();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->setBlur((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 8: { float _r = _t->spread();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 9: _t->setSpread((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 10: { QColor _r = _t->color();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 11: _t->setColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1]))); break;
        case 12: { float _r = _t->topLeftRadius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 13: _t->setTopLeftRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 14: { float _r = _t->topRightRadius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 15: _t->setTopRightRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 16: { float _r = _t->bottomLeftRadius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 17: _t->setBottomLeftRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 18: { float _r = _t->bottomRightRadius();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 19: _t->setBottomRightRadius((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        default: ;
        }
    }
}
namespace {
struct qt_meta_tag_ZN30QCanvas2DImagePatternValueTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto QCanvas2DImagePatternValueType::qt_create_metaobjectdata<qt_meta_tag_ZN30QCanvas2DImagePatternValueTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCanvas2DImagePatternValueType",
        "QML.AddedInVersion",
        "1548",
        "QML.Foreign",
        "QCanvasImagePattern",
        "QML.Element",
        "imagepattern2d",
        "QML.Extended",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "structured",
        "startPosition",
        "QPointF",
        "",
        "setStartPosition",
        "x",
        "y",
        "point",
        "imageSize",
        "QSizeF",
        "setImageSize",
        "width",
        "height",
        "size",
        "rotation",
        "setRotation",
        "tintColor",
        "QColor",
        "setTintColor",
        "color"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'startPosition'
        QtMocHelpers::MethodData<QPointF() const>(12, 14, QMC::AccessPublic, 0x80000000 | 13),
        // Method 'setStartPosition'
        QtMocHelpers::MethodData<void(float, float)>(15, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 16 }, { QMetaType::Float, 17 },
        }}),
        // Method 'setStartPosition'
        QtMocHelpers::MethodData<void(QPointF)>(15, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 18 },
        }}),
        // Method 'imageSize'
        QtMocHelpers::MethodData<QSizeF() const>(19, 14, QMC::AccessPublic, 0x80000000 | 20),
        // Method 'setImageSize'
        QtMocHelpers::MethodData<void(float, float)>(21, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 22 }, { QMetaType::Float, 23 },
        }}),
        // Method 'setImageSize'
        QtMocHelpers::MethodData<void(QSizeF)>(21, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 24 },
        }}),
        // Method 'rotation'
        QtMocHelpers::MethodData<float() const>(25, 14, QMC::AccessPublic, QMetaType::Float),
        // Method 'setRotation'
        QtMocHelpers::MethodData<void(float)>(26, 14, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 25 },
        }}),
        // Method 'tintColor'
        QtMocHelpers::MethodData<QColor() const>(27, 14, QMC::AccessPublic, 0x80000000 | 28),
        // Method 'setTintColor'
        QtMocHelpers::MethodData<void(const QColor &)>(29, 14, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 30 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor()>(14, QMC::AccessPublic),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    0 },
            {    8,    9 },
            {   10,   11 },
    });
    return QtMocHelpers::metaObjectData<QCanvas2DImagePatternValueType, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject QCanvas2DImagePatternValueType::staticMetaObject = { {
    QtPrivate::MetaObjectForType<QCanvasImagePattern>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30QCanvas2DImagePatternValueTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30QCanvas2DImagePatternValueTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN30QCanvas2DImagePatternValueTypeE_t>.metaTypes,
    nullptr
} };

void QCanvas2DImagePatternValueType::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<QCanvas2DImagePatternValueType *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { QCanvas2DImagePatternValueType *_r = new QCanvas2DImagePatternValueType();
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) QCanvas2DImagePatternValueType(); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QPointF _r = _t->startPosition();
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 1: _t->setStartPosition((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 2: _t->setStartPosition((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 3: { QSizeF _r = _t->imageSize();
            if (_a[0]) *reinterpret_cast<QSizeF*>(_a[0]) = std::move(_r); }  break;
        case 4: _t->setImageSize((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2]))); break;
        case 5: _t->setImageSize((*reinterpret_cast<std::add_pointer_t<QSizeF>>(_a[1]))); break;
        case 6: { float _r = _t->rotation();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->setRotation((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 8: { QColor _r = _t->tintColor();
            if (_a[0]) *reinterpret_cast<QColor*>(_a[0]) = std::move(_r); }  break;
        case 9: _t->setTintColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1]))); break;
        default: ;
        }
    }
}
QT_WARNING_POP
