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

#include "../../../../../JKQtPlotter/lib/jkqtplotter/jkqtpgraphsbasestylingmixins.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 'jkqtpgraphsbasestylingmixins.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN24JKQTPGraphLineStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphLineStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN24JKQTPGraphLineStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphLineStyleMixin",
        "highlightingLineColor",
        "QColor",
        "lineColor",
        "lineStyle",
        "Qt::PenStyle",
        "lineWidth"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'highlightingLineColor'
        QtMocHelpers::PropertyData<QColor>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'lineColor'
        QtMocHelpers::PropertyData<QColor>(3, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'lineStyle'
        QtMocHelpers::PropertyData<Qt::PenStyle>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'lineWidth'
        QtMocHelpers::PropertyData<double>(6, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphLineStyleMixin, qt_meta_tag_ZN24JKQTPGraphLineStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphLineStyleMixin::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JKQTPGraphLineStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JKQTPGraphLineStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24JKQTPGraphLineStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphLineStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphLineStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QColor*>(_v) = _t->getHighlightingLineColor(); break;
        case 1: *reinterpret_cast<QColor*>(_v) = _t->getLineColor(); break;
        case 2: *reinterpret_cast<Qt::PenStyle*>(_v) = _t->getLineStyle(); break;
        case 3: *reinterpret_cast<double*>(_v) = _t->getLineWidth(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setHighlightingLineColor(*reinterpret_cast<QColor*>(_v)); break;
        case 1: _t->setLineColor(*reinterpret_cast<QColor*>(_v)); break;
        case 2: _t->setLineStyle(*reinterpret_cast<Qt::PenStyle*>(_v)); break;
        case 3: _t->setLineWidth(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN31JKQTPGraphLinesCompressionMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphLinesCompressionMixin::qt_create_metaobjectdata<qt_meta_tag_ZN31JKQTPGraphLinesCompressionMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphLinesCompressionMixin",
        "useNonvisibleLineCompression",
        "nonvisibleLineCompressionAgressiveness"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'useNonvisibleLineCompression'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'nonvisibleLineCompressionAgressiveness'
        QtMocHelpers::PropertyData<double>(2, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphLinesCompressionMixin, qt_meta_tag_ZN31JKQTPGraphLinesCompressionMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphLinesCompressionMixin::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31JKQTPGraphLinesCompressionMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31JKQTPGraphLinesCompressionMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31JKQTPGraphLinesCompressionMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphLinesCompressionMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphLinesCompressionMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->getUseNonvisibleLineCompression(); break;
        case 1: *reinterpret_cast<double*>(_v) = _t->getNonvisibleLineCompressionAgressiveness(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setUseNonvisibleLineCompression(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setNonvisibleLineCompressionAgressiveness(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN37JKQTPGraphDecoratedHeadLineStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphDecoratedHeadLineStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN37JKQTPGraphDecoratedHeadLineStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphDecoratedHeadLineStyleMixin",
        "headDecoratorStyle",
        "JKQTPLineDecoratorStyle",
        "headDecoratorSizeFactor"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'headDecoratorStyle'
        QtMocHelpers::PropertyData<JKQTPLineDecoratorStyle>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'headDecoratorSizeFactor'
        QtMocHelpers::PropertyData<double>(3, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphDecoratedHeadLineStyleMixin, qt_meta_tag_ZN37JKQTPGraphDecoratedHeadLineStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphDecoratedHeadLineStyleMixin::staticMetaObject = { {
    QtPrivate::MetaObjectForType<JKQTPGraphLineStyleMixin>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN37JKQTPGraphDecoratedHeadLineStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN37JKQTPGraphDecoratedHeadLineStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN37JKQTPGraphDecoratedHeadLineStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphDecoratedHeadLineStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphDecoratedHeadLineStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<JKQTPLineDecoratorStyle*>(_v) = _t->getHeadDecoratorStyle(); break;
        case 1: *reinterpret_cast<double*>(_v) = _t->getHeadDecoratorSizeFactor(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setHeadDecoratorStyle(*reinterpret_cast<JKQTPLineDecoratorStyle*>(_v)); break;
        case 1: _t->setHeadDecoratorSizeFactor(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN33JKQTPGraphDecoratedLineStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphDecoratedLineStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN33JKQTPGraphDecoratedLineStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphDecoratedLineStyleMixin",
        "headDecoratorStyle",
        "JKQTPLineDecoratorStyle",
        "tailDecoratorStyle",
        "headDecoratorSizeFactor",
        "tailDecoratorSizeFactor"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'headDecoratorStyle'
        QtMocHelpers::PropertyData<JKQTPLineDecoratorStyle>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'tailDecoratorStyle'
        QtMocHelpers::PropertyData<JKQTPLineDecoratorStyle>(3, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'headDecoratorSizeFactor'
        QtMocHelpers::PropertyData<double>(4, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'tailDecoratorSizeFactor'
        QtMocHelpers::PropertyData<double>(5, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphDecoratedLineStyleMixin, qt_meta_tag_ZN33JKQTPGraphDecoratedLineStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphDecoratedLineStyleMixin::staticMetaObject = { {
    QtPrivate::MetaObjectForType<JKQTPGraphLineStyleMixin>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33JKQTPGraphDecoratedLineStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33JKQTPGraphDecoratedLineStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33JKQTPGraphDecoratedLineStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphDecoratedLineStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphDecoratedLineStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<JKQTPLineDecoratorStyle*>(_v) = _t->getHeadDecoratorStyle(); break;
        case 1: *reinterpret_cast<JKQTPLineDecoratorStyle*>(_v) = _t->getTailDecoratorStyle(); break;
        case 2: *reinterpret_cast<double*>(_v) = _t->getHeadDecoratorSizeFactor(); break;
        case 3: *reinterpret_cast<double*>(_v) = _t->getTailDecoratorSizeFactor(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setHeadDecoratorStyle(*reinterpret_cast<JKQTPLineDecoratorStyle*>(_v)); break;
        case 1: _t->setTailDecoratorStyle(*reinterpret_cast<JKQTPLineDecoratorStyle*>(_v)); break;
        case 2: _t->setHeadDecoratorSizeFactor(*reinterpret_cast<double*>(_v)); break;
        case 3: _t->setTailDecoratorSizeFactor(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN26JKQTPGraphSymbolStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphSymbolStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN26JKQTPGraphSymbolStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphSymbolStyleMixin",
        "symbolType",
        "JKQTPGraphSymbols",
        "symbolColor",
        "QColor",
        "symbolFillColor",
        "symbolSize",
        "symbolLineWidth",
        "symbolFontName"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'symbolType'
        QtMocHelpers::PropertyData<JKQTPGraphSymbols>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'symbolColor'
        QtMocHelpers::PropertyData<QColor>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'symbolFillColor'
        QtMocHelpers::PropertyData<QColor>(5, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'symbolSize'
        QtMocHelpers::PropertyData<double>(6, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'symbolLineWidth'
        QtMocHelpers::PropertyData<double>(7, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'symbolFontName'
        QtMocHelpers::PropertyData<QString>(8, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphSymbolStyleMixin, qt_meta_tag_ZN26JKQTPGraphSymbolStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphSymbolStyleMixin::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26JKQTPGraphSymbolStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26JKQTPGraphSymbolStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26JKQTPGraphSymbolStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphSymbolStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphSymbolStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<JKQTPGraphSymbols*>(_v) = _t->getSymbolType(); break;
        case 1: *reinterpret_cast<QColor*>(_v) = _t->getSymbolColor(); break;
        case 2: *reinterpret_cast<QColor*>(_v) = _t->getSymbolFillColor(); break;
        case 3: *reinterpret_cast<double*>(_v) = _t->getSymbolSize(); break;
        case 4: *reinterpret_cast<double*>(_v) = _t->getSymbolLineWidth(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->getSymbolFontName(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setSymbolType(*reinterpret_cast<JKQTPGraphSymbols*>(_v)); break;
        case 1: _t->setSymbolColor(*reinterpret_cast<QColor*>(_v)); break;
        case 2: _t->setSymbolFillColor(*reinterpret_cast<QColor*>(_v)); break;
        case 3: _t->setSymbolSize(*reinterpret_cast<double*>(_v)); break;
        case 4: _t->setSymbolLineWidth(*reinterpret_cast<double*>(_v)); break;
        case 5: _t->setSymbolFontName(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN24JKQTPGraphFillStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphFillStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN24JKQTPGraphFillStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphFillStyleMixin",
        "fillStyle",
        "Qt::BrushStyle",
        "fillColor",
        "QColor"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'fillStyle'
        QtMocHelpers::PropertyData<Qt::BrushStyle>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'fillColor'
        QtMocHelpers::PropertyData<QColor>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphFillStyleMixin, qt_meta_tag_ZN24JKQTPGraphFillStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphFillStyleMixin::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JKQTPGraphFillStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JKQTPGraphFillStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24JKQTPGraphFillStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphFillStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphFillStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<Qt::BrushStyle*>(_v) = _t->getFillStyle(); break;
        case 1: *reinterpret_cast<QColor*>(_v) = _t->getFillColor(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFillStyle(*reinterpret_cast<Qt::BrushStyle*>(_v)); break;
        case 1: _t->setFillColor(*reinterpret_cast<QColor*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN31JKQTPGraphLineAndFillStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphLineAndFillStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN31JKQTPGraphLineAndFillStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphLineAndFillStyleMixin",
        "drawLine",
        "fillCurve"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'drawLine'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'fillCurve'
        QtMocHelpers::PropertyData<bool>(2, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphLineAndFillStyleMixin, qt_meta_tag_ZN31JKQTPGraphLineAndFillStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphLineAndFillStyleMixin::staticMetaObject = { {
    QtPrivate::MetaObjectForType<JKQTPGraphFillStyleMixin>::value,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31JKQTPGraphLineAndFillStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31JKQTPGraphLineAndFillStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31JKQTPGraphLineAndFillStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphLineAndFillStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphLineAndFillStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->getDrawLine(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFillCurve(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setDrawLine(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFillCurve(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN24JKQTPGraphTextStyleMixinE_t {};
} // unnamed namespace

template <> constexpr inline auto JKQTPGraphTextStyleMixin::qt_create_metaobjectdata<qt_meta_tag_ZN24JKQTPGraphTextStyleMixinE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "JKQTPGraphTextStyleMixin",
        "textColor",
        "QColor",
        "textFontSize",
        "textFontName"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'textColor'
        QtMocHelpers::PropertyData<QColor>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'textFontSize'
        QtMocHelpers::PropertyData<double>(3, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'textFontName'
        QtMocHelpers::PropertyData<QString>(4, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<JKQTPGraphTextStyleMixin, qt_meta_tag_ZN24JKQTPGraphTextStyleMixinE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject JKQTPGraphTextStyleMixin::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JKQTPGraphTextStyleMixinE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24JKQTPGraphTextStyleMixinE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24JKQTPGraphTextStyleMixinE_t>.metaTypes,
    nullptr
} };

void JKQTPGraphTextStyleMixin::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<JKQTPGraphTextStyleMixin *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QColor*>(_v) = _t->getTextColor(); break;
        case 1: *reinterpret_cast<double*>(_v) = _t->getTextFontSize(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->getTextFontName(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setTextColor(*reinterpret_cast<QColor*>(_v)); break;
        case 1: _t->setTextFontSize(*reinterpret_cast<double*>(_v)); break;
        case 2: _t->setTextFontName(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}
QT_WARNING_POP
