lenn/ts-qt
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b2350a3b3564c022cdb5205e364f06b9db986c73
ts-qt/mingw-build/qcustomplot_autogen/EIXI6URBL5/moc_qcustomplot.cpp

7070 lines
294 KiB
C++
Raw Blame History

/****************************************************************************
** Meta object code from reading C++ file 'qcustomplot.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.9.2)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../qcustomplot/qcustomplot.h"
#include <QtGui/qtextcursor.h>
#include <QtGui/qscreen.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QSharedPointer>
#include <QtCore/QList>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'qcustomplot.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.9.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_ZN10QCPPainterE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPainter::qt_create_metaobjectdata<qt_meta_tag_ZN10QCPPainterE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPainter",
"PainterMode",
"pmDefault",
"pmVectorized",
"pmNoCaching",
"pmNonCosmetic",
"PainterModes"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'PainterMode'
QtMocHelpers::EnumData<enum PainterMode>(1, 1, QMC::EnumFlags{}).add({
{ 2, PainterMode::pmDefault },
{ 3, PainterMode::pmVectorized },
{ 4, PainterMode::pmNoCaching },
{ 5, PainterMode::pmNonCosmetic },
}),
// enum 'PainterModes'
QtMocHelpers::EnumData<PainterModes>(6, 1, QMC::EnumFlags{}).add({
{ 2, PainterMode::pmDefault },
{ 3, PainterMode::pmVectorized },
{ 4, PainterMode::pmNoCaching },
{ 5, PainterMode::pmNonCosmetic },
}),
};
return QtMocHelpers::metaObjectData<QCPPainter, qt_meta_tag_ZN10QCPPainterE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPainter::staticMetaObject = { {
QtPrivate::MetaObjectForType<QPainter>::value,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10QCPPainterE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10QCPPainterE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10QCPPainterE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN8QCPLayerE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLayer::qt_create_metaobjectdata<qt_meta_tag_ZN8QCPLayerE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLayer",
"parentPlot",
"QCustomPlot*",
"name",
"index",
"children",
"QList<QCPLayerable*>",
"visible",
"mode",
"LayerMode",
"lmLogical",
"lmBuffered"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'parentPlot'
QtMocHelpers::PropertyData<QCustomPlot*>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'name'
QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags),
// property 'index'
QtMocHelpers::PropertyData<int>(4, QMetaType::Int, QMC::DefaultPropertyFlags),
// property 'children'
QtMocHelpers::PropertyData<QList<QCPLayerable*>>(5, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'visible'
QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'mode'
QtMocHelpers::PropertyData<enum LayerMode>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'LayerMode'
QtMocHelpers::EnumData<enum LayerMode>(9, 9, QMC::EnumFlags{}).add({
{ 10, LayerMode::lmLogical },
{ 11, LayerMode::lmBuffered },
}),
};
return QtMocHelpers::metaObjectData<QCPLayer, qt_meta_tag_ZN8QCPLayerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLayer::staticMetaObject = { {
QMetaObject::SuperData::link<QObject::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPLayerE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPLayerE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8QCPLayerE_t>.metaTypes,
nullptr
} };
void QCPLayer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLayer *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 0:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCustomPlot* >(); break;
case 3:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QCPLayerable*> >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QCustomPlot**>(_v) = _t->parentPlot(); break;
case 1: *reinterpret_cast<QString*>(_v) = _t->name(); break;
case 2: *reinterpret_cast<int*>(_v) = _t->index(); break;
case 3: *reinterpret_cast<QList<QCPLayerable*>*>(_v) = _t->children(); break;
case 4: *reinterpret_cast<bool*>(_v) = _t->visible(); break;
case 5: *reinterpret_cast<enum LayerMode*>(_v) = _t->mode(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 4: _t->setVisible(*reinterpret_cast<bool*>(_v)); break;
case 5: _t->setMode(*reinterpret_cast<enum LayerMode*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPLayer::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLayer::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPLayerE_t>.strings))
return static_cast<void*>(this);
return QObject::qt_metacast(_clname);
}
int QCPLayer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN12QCPLayerableE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLayerable::qt_create_metaobjectdata<qt_meta_tag_ZN12QCPLayerableE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLayerable",
"layerChanged",
"",
"QCPLayer*",
"newLayer",
"setLayer",
"layer",
"visible",
"parentPlot",
"QCustomPlot*",
"parentLayerable",
"QCPLayerable*",
"antialiased"
};
QtMocHelpers::UintData qt_methods {
// Signal 'layerChanged'
QtMocHelpers::SignalData<void(QCPLayer *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Slot 'setLayer'
QtMocHelpers::SlotData<bool(QCPLayer *)>(5, 2, QMC::AccessPublic, QMetaType::Bool, {{
{ 0x80000000 | 3, 6 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'visible'
QtMocHelpers::PropertyData<bool>(7, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'parentPlot'
QtMocHelpers::PropertyData<QCustomPlot*>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'parentLayerable'
QtMocHelpers::PropertyData<QCPLayerable*>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'layer'
QtMocHelpers::PropertyData<QCPLayer*>(6, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
// property 'antialiased'
QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPLayerable, qt_meta_tag_ZN12QCPLayerableE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLayerable::staticMetaObject = { {
QMetaObject::SuperData::link<QObject::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPLayerableE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPLayerableE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QCPLayerableE_t>.metaTypes,
nullptr
} };
void QCPLayerable::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLayerable *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->layerChanged((*reinterpret_cast< std::add_pointer_t<QCPLayer*>>(_a[1]))); break;
case 1: { bool _r = _t->setLayer((*reinterpret_cast< std::add_pointer_t<QCPLayer*>>(_a[1])));
if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); } break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPLayer* >(); break;
}
break;
case 1:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPLayer* >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPLayerable::*)(QCPLayer * )>(_a, &QCPLayerable::layerChanged, 0))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 3:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayer* >(); break;
case 2:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayerable* >(); break;
case 1:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCustomPlot* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<bool*>(_v) = _t->visible(); break;
case 1: *reinterpret_cast<QCustomPlot**>(_v) = _t->parentPlot(); break;
case 2: *reinterpret_cast<QCPLayerable**>(_v) = _t->parentLayerable(); break;
case 3: *reinterpret_cast<QCPLayer**>(_v) = _t->layer(); break;
case 4: *reinterpret_cast<bool*>(_v) = _t->antialiased(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setVisible(*reinterpret_cast<bool*>(_v)); break;
case 3: _t->setLayer(*reinterpret_cast<QCPLayer**>(_v)); break;
case 4: _t->setAntialiased(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPLayerable::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLayerable::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPLayerableE_t>.strings))
return static_cast<void*>(this);
return QObject::qt_metacast(_clname);
}
int QCPLayerable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
return _id;
}
// SIGNAL 0
void QCPLayerable::layerChanged(QCPLayer * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN16QCPSelectionRectE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPSelectionRect::qt_create_metaobjectdata<qt_meta_tag_ZN16QCPSelectionRectE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPSelectionRect",
"started",
"",
"QMouseEvent*",
"event",
"changed",
"rect",
"canceled",
"QInputEvent*",
"accepted",
"cancel"
};
QtMocHelpers::UintData qt_methods {
// Signal 'started'
QtMocHelpers::SignalData<void(QMouseEvent *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'changed'
QtMocHelpers::SignalData<void(const QRect &, QMouseEvent *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QRect, 6 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'canceled'
QtMocHelpers::SignalData<void(const QRect &, QInputEvent *)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QRect, 6 }, { 0x80000000 | 8, 4 },
}}),
// Signal 'accepted'
QtMocHelpers::SignalData<void(const QRect &, QMouseEvent *)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QRect, 6 }, { 0x80000000 | 3, 4 },
}}),
// Slot 'cancel'
QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPSelectionRect, qt_meta_tag_ZN16QCPSelectionRectE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPSelectionRect::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPSelectionRectE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPSelectionRectE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QCPSelectionRectE_t>.metaTypes,
nullptr
} };
void QCPSelectionRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPSelectionRect *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->started((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 1: _t->changed((*reinterpret_cast< std::add_pointer_t<QRect>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[2]))); break;
case 2: _t->canceled((*reinterpret_cast< std::add_pointer_t<QRect>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QInputEvent*>>(_a[2]))); break;
case 3: _t->accepted((*reinterpret_cast< std::add_pointer_t<QRect>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[2]))); break;
case 4: _t->cancel(); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPSelectionRect::*)(QMouseEvent * )>(_a, &QCPSelectionRect::started, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPSelectionRect::*)(const QRect & , QMouseEvent * )>(_a, &QCPSelectionRect::changed, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPSelectionRect::*)(const QRect & , QInputEvent * )>(_a, &QCPSelectionRect::canceled, 2))
return;
if (QtMocHelpers::indexOfMethod<void (QCPSelectionRect::*)(const QRect & , QMouseEvent * )>(_a, &QCPSelectionRect::accepted, 3))
return;
}
}
const QMetaObject *QCPSelectionRect::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPSelectionRect::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPSelectionRectE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPSelectionRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 5)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 5;
}
return _id;
}
// SIGNAL 0
void QCPSelectionRect::started(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPSelectionRect::changed(const QRect & _t1, QMouseEvent * _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}
// SIGNAL 2
void QCPSelectionRect::canceled(const QRect & _t1, QInputEvent * _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}
// SIGNAL 3
void QCPSelectionRect::accepted(const QRect & _t1, QMouseEvent * _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2);
}
namespace {
struct qt_meta_tag_ZN14QCPMarginGroupE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPMarginGroup::qt_create_metaobjectdata<qt_meta_tag_ZN14QCPMarginGroupE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPMarginGroup"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPMarginGroup, qt_meta_tag_ZN14QCPMarginGroupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPMarginGroup::staticMetaObject = { {
QMetaObject::SuperData::link<QObject::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPMarginGroupE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPMarginGroupE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QCPMarginGroupE_t>.metaTypes,
nullptr
} };
void QCPMarginGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPMarginGroup *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *QCPMarginGroup::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPMarginGroup::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPMarginGroupE_t>.strings))
return static_cast<void*>(this);
return QObject::qt_metacast(_clname);
}
int QCPMarginGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN16QCPLayoutElementE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLayoutElement::qt_create_metaobjectdata<qt_meta_tag_ZN16QCPLayoutElementE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLayoutElement",
"layout",
"QCPLayout*",
"rect",
"outerRect",
"margins",
"QMargins",
"minimumMargins",
"minimumSize",
"maximumSize",
"sizeConstraintRect",
"SizeConstraintRect",
"UpdatePhase",
"upPreparation",
"upMargins",
"upLayout",
"scrInnerRect",
"scrOuterRect"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'layout'
QtMocHelpers::PropertyData<QCPLayout*>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'rect'
QtMocHelpers::PropertyData<QRect>(3, QMetaType::QRect, QMC::DefaultPropertyFlags),
// property 'outerRect'
QtMocHelpers::PropertyData<QRect>(4, QMetaType::QRect, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'margins'
QtMocHelpers::PropertyData<QMargins>(5, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'minimumMargins'
QtMocHelpers::PropertyData<QMargins>(7, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'minimumSize'
QtMocHelpers::PropertyData<QSize>(8, QMetaType::QSize, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'maximumSize'
QtMocHelpers::PropertyData<QSize>(9, QMetaType::QSize, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'sizeConstraintRect'
QtMocHelpers::PropertyData<enum SizeConstraintRect>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'UpdatePhase'
QtMocHelpers::EnumData<enum UpdatePhase>(12, 12, QMC::EnumFlags{}).add({
{ 13, UpdatePhase::upPreparation },
{ 14, UpdatePhase::upMargins },
{ 15, UpdatePhase::upLayout },
}),
// enum 'SizeConstraintRect'
QtMocHelpers::EnumData<enum SizeConstraintRect>(11, 11, QMC::EnumFlags{}).add({
{ 16, SizeConstraintRect::scrInnerRect },
{ 17, SizeConstraintRect::scrOuterRect },
}),
};
return QtMocHelpers::metaObjectData<QCPLayoutElement, qt_meta_tag_ZN16QCPLayoutElementE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLayoutElement::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPLayoutElementE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPLayoutElementE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QCPLayoutElementE_t>.metaTypes,
nullptr
} };
void QCPLayoutElement::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLayoutElement *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 0:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayout* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QCPLayout**>(_v) = _t->layout(); break;
case 1: *reinterpret_cast<QRect*>(_v) = _t->rect(); break;
case 2: *reinterpret_cast<QRect*>(_v) = _t->outerRect(); break;
case 3: *reinterpret_cast<QMargins*>(_v) = _t->margins(); break;
case 4: *reinterpret_cast<QMargins*>(_v) = _t->minimumMargins(); break;
case 5: *reinterpret_cast<QSize*>(_v) = _t->minimumSize(); break;
case 6: *reinterpret_cast<QSize*>(_v) = _t->maximumSize(); break;
case 7: *reinterpret_cast<enum SizeConstraintRect*>(_v) = _t->sizeConstraintRect(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 2: _t->setOuterRect(*reinterpret_cast<QRect*>(_v)); break;
case 3: _t->setMargins(*reinterpret_cast<QMargins*>(_v)); break;
case 4: _t->setMinimumMargins(*reinterpret_cast<QMargins*>(_v)); break;
case 5: _t->setMinimumSize(*reinterpret_cast<QSize*>(_v)); break;
case 6: _t->setMaximumSize(*reinterpret_cast<QSize*>(_v)); break;
case 7: _t->setSizeConstraintRect(*reinterpret_cast<enum SizeConstraintRect*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPLayoutElement::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLayoutElement::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPLayoutElementE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPLayoutElement::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN9QCPLayoutE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLayout::qt_create_metaobjectdata<qt_meta_tag_ZN9QCPLayoutE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLayout"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPLayout, qt_meta_tag_ZN9QCPLayoutE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLayout::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9QCPLayoutE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9QCPLayoutE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9QCPLayoutE_t>.metaTypes,
nullptr
} };
void QCPLayout::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLayout *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *QCPLayout::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLayout::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9QCPLayoutE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutElement::qt_metacast(_clname);
}
int QCPLayout::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutElement::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN13QCPLayoutGridE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLayoutGrid::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPLayoutGridE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLayoutGrid",
"rowCount",
"columnCount",
"columnStretchFactors",
"QList<double>",
"rowStretchFactors",
"columnSpacing",
"rowSpacing",
"fillOrder",
"FillOrder",
"wrap",
"foRowsFirst",
"foColumnsFirst"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'rowCount'
QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
// property 'columnCount'
QtMocHelpers::PropertyData<int>(2, QMetaType::Int, QMC::DefaultPropertyFlags),
// property 'columnStretchFactors'
QtMocHelpers::PropertyData<QList<double>>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'rowStretchFactors'
QtMocHelpers::PropertyData<QList<double>>(5, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'columnSpacing'
QtMocHelpers::PropertyData<int>(6, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'rowSpacing'
QtMocHelpers::PropertyData<int>(7, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'fillOrder'
QtMocHelpers::PropertyData<enum FillOrder>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'wrap'
QtMocHelpers::PropertyData<int>(10, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'FillOrder'
QtMocHelpers::EnumData<enum FillOrder>(9, 9, QMC::EnumFlags{}).add({
{ 11, FillOrder::foRowsFirst },
{ 12, FillOrder::foColumnsFirst },
}),
};
return QtMocHelpers::metaObjectData<QCPLayoutGrid, qt_meta_tag_ZN13QCPLayoutGridE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLayoutGrid::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayout::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPLayoutGridE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPLayoutGridE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPLayoutGridE_t>.metaTypes,
nullptr
} };
void QCPLayoutGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLayoutGrid *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 3:
case 2:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<double> >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<int*>(_v) = _t->rowCount(); break;
case 1: *reinterpret_cast<int*>(_v) = _t->columnCount(); break;
case 2: *reinterpret_cast<QList<double>*>(_v) = _t->columnStretchFactors(); break;
case 3: *reinterpret_cast<QList<double>*>(_v) = _t->rowStretchFactors(); break;
case 4: *reinterpret_cast<int*>(_v) = _t->columnSpacing(); break;
case 5: *reinterpret_cast<int*>(_v) = _t->rowSpacing(); break;
case 6: *reinterpret_cast<enum FillOrder*>(_v) = _t->fillOrder(); break;
case 7: *reinterpret_cast<int*>(_v) = _t->wrap(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 2: _t->setColumnStretchFactors(*reinterpret_cast<QList<double>*>(_v)); break;
case 3: _t->setRowStretchFactors(*reinterpret_cast<QList<double>*>(_v)); break;
case 4: _t->setColumnSpacing(*reinterpret_cast<int*>(_v)); break;
case 5: _t->setRowSpacing(*reinterpret_cast<int*>(_v)); break;
case 6: _t->setFillOrder(*reinterpret_cast<enum FillOrder*>(_v)); break;
case 7: _t->setWrap(*reinterpret_cast<int*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPLayoutGrid::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLayoutGrid::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPLayoutGridE_t>.strings))
return static_cast<void*>(this);
return QCPLayout::qt_metacast(_clname);
}
int QCPLayoutGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayout::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN14QCPLayoutInsetE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLayoutInset::qt_create_metaobjectdata<qt_meta_tag_ZN14QCPLayoutInsetE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLayoutInset",
"InsetPlacement",
"ipFree",
"ipBorderAligned"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'InsetPlacement'
QtMocHelpers::EnumData<enum InsetPlacement>(1, 1, QMC::EnumFlags{}).add({
{ 2, InsetPlacement::ipFree },
{ 3, InsetPlacement::ipBorderAligned },
}),
};
return QtMocHelpers::metaObjectData<QCPLayoutInset, qt_meta_tag_ZN14QCPLayoutInsetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLayoutInset::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayout::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPLayoutInsetE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPLayoutInsetE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QCPLayoutInsetE_t>.metaTypes,
nullptr
} };
void QCPLayoutInset::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLayoutInset *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *QCPLayoutInset::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLayoutInset::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPLayoutInsetE_t>.strings))
return static_cast<void*>(this);
return QCPLayout::qt_metacast(_clname);
}
int QCPLayoutInset::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayout::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN13QCPLineEndingE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLineEnding::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPLineEndingE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLineEnding",
"EndingStyle",
"esNone",
"esFlatArrow",
"esSpikeArrow",
"esLineArrow",
"esDisc",
"esSquare",
"esDiamond",
"esBar",
"esHalfBar",
"esSkewedBar"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'EndingStyle'
QtMocHelpers::EnumData<enum EndingStyle>(1, 1, QMC::EnumFlags{}).add({
{ 2, EndingStyle::esNone },
{ 3, EndingStyle::esFlatArrow },
{ 4, EndingStyle::esSpikeArrow },
{ 5, EndingStyle::esLineArrow },
{ 6, EndingStyle::esDisc },
{ 7, EndingStyle::esSquare },
{ 8, EndingStyle::esDiamond },
{ 9, EndingStyle::esBar },
{ 10, EndingStyle::esHalfBar },
{ 11, EndingStyle::esSkewedBar },
}),
};
return QtMocHelpers::metaObjectData<QCPLineEnding, qt_meta_tag_ZN13QCPLineEndingE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLineEnding::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPLineEndingE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPLineEndingE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPLineEndingE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN22QCPLabelPainterPrivateE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLabelPainterPrivate::qt_create_metaobjectdata<qt_meta_tag_ZN22QCPLabelPainterPrivateE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLabelPainterPrivate",
"AnchorMode",
"amRectangular",
"amSkewedUpright",
"amSkewedRotated",
"AnchorReferenceType",
"artNormal",
"artTangent",
"AnchorSide",
"asLeft",
"asRight",
"asTop",
"asBottom",
"asTopLeft",
"asTopRight",
"asBottomRight",
"asBottomLeft"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'AnchorMode'
QtMocHelpers::EnumData<enum AnchorMode>(1, 1, QMC::EnumFlags{}).add({
{ 2, AnchorMode::amRectangular },
{ 3, AnchorMode::amSkewedUpright },
{ 4, AnchorMode::amSkewedRotated },
}),
// enum 'AnchorReferenceType'
QtMocHelpers::EnumData<enum AnchorReferenceType>(5, 5, QMC::EnumFlags{}).add({
{ 6, AnchorReferenceType::artNormal },
{ 7, AnchorReferenceType::artTangent },
}),
// enum 'AnchorSide'
QtMocHelpers::EnumData<enum AnchorSide>(8, 8, QMC::EnumFlags{}).add({
{ 9, AnchorSide::asLeft },
{ 10, AnchorSide::asRight },
{ 11, AnchorSide::asTop },
{ 12, AnchorSide::asBottom },
{ 13, AnchorSide::asTopLeft },
{ 14, AnchorSide::asTopRight },
{ 15, AnchorSide::asBottomRight },
{ 16, AnchorSide::asBottomLeft },
}),
};
return QtMocHelpers::metaObjectData<QCPLabelPainterPrivate, qt_meta_tag_ZN22QCPLabelPainterPrivateE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLabelPainterPrivate::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCPLabelPainterPrivateE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCPLabelPainterPrivateE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QCPLabelPainterPrivateE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN13QCPAxisTickerE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAxisTicker::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPAxisTickerE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAxisTicker",
"TickStepStrategy",
"tssReadability",
"tssMeetTickCount"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'TickStepStrategy'
QtMocHelpers::EnumData<enum TickStepStrategy>(1, 1, QMC::EnumFlags{}).add({
{ 2, TickStepStrategy::tssReadability },
{ 3, TickStepStrategy::tssMeetTickCount },
}),
};
return QtMocHelpers::metaObjectData<QCPAxisTicker, qt_meta_tag_ZN13QCPAxisTickerE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAxisTicker::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPAxisTickerE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPAxisTickerE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPAxisTickerE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN17QCPAxisTickerTimeE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAxisTickerTime::qt_create_metaobjectdata<qt_meta_tag_ZN17QCPAxisTickerTimeE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAxisTickerTime",
"TimeUnit",
"tuMilliseconds",
"tuSeconds",
"tuMinutes",
"tuHours",
"tuDays"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'TimeUnit'
QtMocHelpers::EnumData<enum TimeUnit>(1, 1, QMC::EnumFlags{}).add({
{ 2, TimeUnit::tuMilliseconds },
{ 3, TimeUnit::tuSeconds },
{ 4, TimeUnit::tuMinutes },
{ 5, TimeUnit::tuHours },
{ 6, TimeUnit::tuDays },
}),
};
return QtMocHelpers::metaObjectData<QCPAxisTickerTime, qt_meta_tag_ZN17QCPAxisTickerTimeE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAxisTickerTime::staticMetaObject = { {
QtPrivate::MetaObjectForType<QCPAxisTicker>::value,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QCPAxisTickerTimeE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QCPAxisTickerTimeE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QCPAxisTickerTimeE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN18QCPAxisTickerFixedE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAxisTickerFixed::qt_create_metaobjectdata<qt_meta_tag_ZN18QCPAxisTickerFixedE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAxisTickerFixed",
"ScaleStrategy",
"ssNone",
"ssMultiples",
"ssPowers"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'ScaleStrategy'
QtMocHelpers::EnumData<enum ScaleStrategy>(1, 1, QMC::EnumFlags{}).add({
{ 2, ScaleStrategy::ssNone },
{ 3, ScaleStrategy::ssMultiples },
{ 4, ScaleStrategy::ssPowers },
}),
};
return QtMocHelpers::metaObjectData<QCPAxisTickerFixed, qt_meta_tag_ZN18QCPAxisTickerFixedE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAxisTickerFixed::staticMetaObject = { {
QtPrivate::MetaObjectForType<QCPAxisTicker>::value,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPAxisTickerFixedE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPAxisTickerFixedE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QCPAxisTickerFixedE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN15QCPAxisTickerPiE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAxisTickerPi::qt_create_metaobjectdata<qt_meta_tag_ZN15QCPAxisTickerPiE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAxisTickerPi",
"FractionStyle",
"fsFloatingPoint",
"fsAsciiFractions",
"fsUnicodeFractions"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'FractionStyle'
QtMocHelpers::EnumData<enum FractionStyle>(1, 1, QMC::EnumFlags{}).add({
{ 2, FractionStyle::fsFloatingPoint },
{ 3, FractionStyle::fsAsciiFractions },
{ 4, FractionStyle::fsUnicodeFractions },
}),
};
return QtMocHelpers::metaObjectData<QCPAxisTickerPi, qt_meta_tag_ZN15QCPAxisTickerPiE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAxisTickerPi::staticMetaObject = { {
QtPrivate::MetaObjectForType<QCPAxisTicker>::value,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPAxisTickerPiE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPAxisTickerPiE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15QCPAxisTickerPiE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN7QCPGridE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPGrid::qt_create_metaobjectdata<qt_meta_tag_ZN7QCPGridE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPGrid",
"subGridVisible",
"antialiasedSubGrid",
"antialiasedZeroLine",
"pen",
"subGridPen",
"zeroLinePen"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'subGridVisible'
QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'antialiasedSubGrid'
QtMocHelpers::PropertyData<bool>(2, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'antialiasedZeroLine'
QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'pen'
QtMocHelpers::PropertyData<QPen>(4, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'subGridPen'
QtMocHelpers::PropertyData<QPen>(5, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'zeroLinePen'
QtMocHelpers::PropertyData<QPen>(6, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPGrid, qt_meta_tag_ZN7QCPGridE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPGrid::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPGridE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPGridE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7QCPGridE_t>.metaTypes,
nullptr
} };
void QCPGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPGrid *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<bool*>(_v) = _t->subGridVisible(); break;
case 1: *reinterpret_cast<bool*>(_v) = _t->antialiasedSubGrid(); break;
case 2: *reinterpret_cast<bool*>(_v) = _t->antialiasedZeroLine(); break;
case 3: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 4: *reinterpret_cast<QPen*>(_v) = _t->subGridPen(); break;
case 5: *reinterpret_cast<QPen*>(_v) = _t->zeroLinePen(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setSubGridVisible(*reinterpret_cast<bool*>(_v)); break;
case 1: _t->setAntialiasedSubGrid(*reinterpret_cast<bool*>(_v)); break;
case 2: _t->setAntialiasedZeroLine(*reinterpret_cast<bool*>(_v)); break;
case 3: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 4: _t->setSubGridPen(*reinterpret_cast<QPen*>(_v)); break;
case 5: _t->setZeroLinePen(*reinterpret_cast<QPen*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPGrid::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPGrid::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPGridE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN7QCPAxisE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAxis::qt_create_metaobjectdata<qt_meta_tag_ZN7QCPAxisE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAxis",
"rangeChanged",
"",
"QCPRange",
"newRange",
"oldRange",
"scaleTypeChanged",
"QCPAxis::ScaleType",
"scaleType",
"selectionChanged",
"QCPAxis::SelectableParts",
"parts",
"selectableChanged",
"setScaleType",
"type",
"setRange",
"range",
"setSelectableParts",
"selectableParts",
"setSelectedParts",
"selectedParts",
"axisType",
"AxisType",
"axisRect",
"QCPAxisRect*",
"ScaleType",
"rangeReversed",
"ticker",
"QSharedPointer<QCPAxisTicker>",
"ticks",
"tickLabels",
"tickLabelPadding",
"tickLabelFont",
"tickLabelColor",
"tickLabelRotation",
"tickLabelSide",
"LabelSide",
"numberFormat",
"numberPrecision",
"tickVector",
"QList<double>",
"tickVectorLabels",
"tickLengthIn",
"tickLengthOut",
"subTicks",
"subTickLengthIn",
"subTickLengthOut",
"basePen",
"tickPen",
"subTickPen",
"labelFont",
"labelColor",
"label",
"labelPadding",
"padding",
"offset",
"SelectableParts",
"selectedTickLabelFont",
"selectedLabelFont",
"selectedTickLabelColor",
"selectedLabelColor",
"selectedBasePen",
"selectedTickPen",
"selectedSubTickPen",
"lowerEnding",
"QCPLineEnding",
"upperEnding",
"grid",
"QCPGrid*",
"atLeft",
"atRight",
"atTop",
"atBottom",
"AxisTypes",
"lsInside",
"lsOutside",
"stLinear",
"stLogarithmic",
"SelectablePart",
"spNone",
"spAxis",
"spTickLabels",
"spAxisLabel"
};
QtMocHelpers::UintData qt_methods {
// Signal 'rangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'rangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &, const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 }, { 0x80000000 | 3, 5 },
}}),
// Signal 'scaleTypeChanged'
QtMocHelpers::SignalData<void(QCPAxis::ScaleType)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(const QCPAxis::SelectableParts &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 11 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(const QCPAxis::SelectableParts &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 11 },
}}),
// Slot 'setScaleType'
QtMocHelpers::SlotData<void(QCPAxis::ScaleType)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 14 },
}}),
// Slot 'setRange'
QtMocHelpers::SlotData<void(const QCPRange &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 16 },
}}),
// Slot 'setSelectableParts'
QtMocHelpers::SlotData<void(const QCPAxis::SelectableParts &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 18 },
}}),
// Slot 'setSelectedParts'
QtMocHelpers::SlotData<void(const QCPAxis::SelectableParts &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 20 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'axisType'
QtMocHelpers::PropertyData<enum AxisType>(21, 0x80000000 | 22, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'axisRect'
QtMocHelpers::PropertyData<QCPAxisRect*>(23, 0x80000000 | 24, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'scaleType'
QtMocHelpers::PropertyData<enum ScaleType>(8, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
// property 'range'
QtMocHelpers::PropertyData<QCPRange>(16, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
// property 'rangeReversed'
QtMocHelpers::PropertyData<bool>(26, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'ticker'
QtMocHelpers::PropertyData<QSharedPointer<QCPAxisTicker>>(27, 0x80000000 | 28, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'ticks'
QtMocHelpers::PropertyData<bool>(29, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLabels'
QtMocHelpers::PropertyData<bool>(30, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLabelPadding'
QtMocHelpers::PropertyData<int>(31, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLabelFont'
QtMocHelpers::PropertyData<QFont>(32, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLabelColor'
QtMocHelpers::PropertyData<QColor>(33, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLabelRotation'
QtMocHelpers::PropertyData<double>(34, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLabelSide'
QtMocHelpers::PropertyData<enum LabelSide>(35, 0x80000000 | 36, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'numberFormat'
QtMocHelpers::PropertyData<QString>(37, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'numberPrecision'
QtMocHelpers::PropertyData<int>(38, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickVector'
QtMocHelpers::PropertyData<QList<double>>(39, 0x80000000 | 40, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'tickVectorLabels'
QtMocHelpers::PropertyData<QList<QString>>(41, QMetaType::QStringList, QMC::DefaultPropertyFlags),
// property 'tickLengthIn'
QtMocHelpers::PropertyData<int>(42, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickLengthOut'
QtMocHelpers::PropertyData<int>(43, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'subTicks'
QtMocHelpers::PropertyData<bool>(44, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'subTickLengthIn'
QtMocHelpers::PropertyData<int>(45, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'subTickLengthOut'
QtMocHelpers::PropertyData<int>(46, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'basePen'
QtMocHelpers::PropertyData<QPen>(47, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tickPen'
QtMocHelpers::PropertyData<QPen>(48, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'subTickPen'
QtMocHelpers::PropertyData<QPen>(49, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'labelFont'
QtMocHelpers::PropertyData<QFont>(50, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'labelColor'
QtMocHelpers::PropertyData<QColor>(51, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'label'
QtMocHelpers::PropertyData<QString>(52, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'labelPadding'
QtMocHelpers::PropertyData<int>(53, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'padding'
QtMocHelpers::PropertyData<int>(54, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'offset'
QtMocHelpers::PropertyData<int>(55, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedParts'
QtMocHelpers::PropertyData<SelectableParts>(20, 0x80000000 | 56, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 3),
// property 'selectableParts'
QtMocHelpers::PropertyData<SelectableParts>(18, 0x80000000 | 56, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 4),
// property 'selectedTickLabelFont'
QtMocHelpers::PropertyData<QFont>(57, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedLabelFont'
QtMocHelpers::PropertyData<QFont>(58, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedTickLabelColor'
QtMocHelpers::PropertyData<QColor>(59, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedLabelColor'
QtMocHelpers::PropertyData<QColor>(60, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedBasePen'
QtMocHelpers::PropertyData<QPen>(61, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedTickPen'
QtMocHelpers::PropertyData<QPen>(62, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedSubTickPen'
QtMocHelpers::PropertyData<QPen>(63, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'lowerEnding'
QtMocHelpers::PropertyData<QCPLineEnding>(64, 0x80000000 | 65, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'upperEnding'
QtMocHelpers::PropertyData<QCPLineEnding>(66, 0x80000000 | 65, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'grid'
QtMocHelpers::PropertyData<QCPGrid*>(67, 0x80000000 | 68, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
};
QtMocHelpers::UintData qt_enums {
// enum 'AxisType'
QtMocHelpers::EnumData<enum AxisType>(22, 22, QMC::EnumFlags{}).add({
{ 69, AxisType::atLeft },
{ 70, AxisType::atRight },
{ 71, AxisType::atTop },
{ 72, AxisType::atBottom },
}),
// enum 'AxisTypes'
QtMocHelpers::EnumData<AxisTypes>(73, 22, QMC::EnumFlags{}).add({
{ 69, AxisType::atLeft },
{ 70, AxisType::atRight },
{ 71, AxisType::atTop },
{ 72, AxisType::atBottom },
}),
// enum 'LabelSide'
QtMocHelpers::EnumData<enum LabelSide>(36, 36, QMC::EnumFlags{}).add({
{ 74, LabelSide::lsInside },
{ 75, LabelSide::lsOutside },
}),
// enum 'ScaleType'
QtMocHelpers::EnumData<enum ScaleType>(25, 25, QMC::EnumFlags{}).add({
{ 76, ScaleType::stLinear },
{ 77, ScaleType::stLogarithmic },
}),
// enum 'SelectablePart'
QtMocHelpers::EnumData<enum SelectablePart>(78, 78, QMC::EnumFlags{}).add({
{ 79, SelectablePart::spNone },
{ 80, SelectablePart::spAxis },
{ 81, SelectablePart::spTickLabels },
{ 82, SelectablePart::spAxisLabel },
}),
// enum 'SelectableParts'
QtMocHelpers::EnumData<SelectableParts>(56, 78, QMC::EnumFlags{}).add({
{ 79, SelectablePart::spNone },
{ 80, SelectablePart::spAxis },
{ 81, SelectablePart::spTickLabels },
{ 82, SelectablePart::spAxisLabel },
}),
};
return QtMocHelpers::metaObjectData<QCPAxis, qt_meta_tag_ZN7QCPAxisE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAxis::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPAxisE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPAxisE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7QCPAxisE_t>.metaTypes,
nullptr
} };
void QCPAxis::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPAxis *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->rangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[2]))); break;
case 2: _t->scaleTypeChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::ScaleType>>(_a[1]))); break;
case 3: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectableParts>>(_a[1]))); break;
case 4: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectableParts>>(_a[1]))); break;
case 5: _t->setScaleType((*reinterpret_cast< std::add_pointer_t<QCPAxis::ScaleType>>(_a[1]))); break;
case 6: _t->setRange((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 7: _t->setSelectableParts((*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectableParts>>(_a[1]))); break;
case 8: _t->setSelectedParts((*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectableParts>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 2:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::ScaleType >(); break;
}
break;
case 5:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::ScaleType >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPAxis::*)(const QCPRange & )>(_a, &QCPAxis::rangeChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAxis::*)(const QCPRange & , const QCPRange & )>(_a, &QCPAxis::rangeChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAxis::*)(QCPAxis::ScaleType )>(_a, &QCPAxis::scaleTypeChanged, 2))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAxis::*)(const QCPAxis::SelectableParts & )>(_a, &QCPAxis::selectionChanged, 3))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAxis::*)(const QCPAxis::SelectableParts & )>(_a, &QCPAxis::selectableChanged, 4))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 1:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxisRect* >(); break;
case 42:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGrid* >(); break;
case 15:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<double> >(); break;
case 5:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QSharedPointer<QCPAxisTicker> >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<enum AxisType*>(_v) = _t->axisType(); break;
case 1: *reinterpret_cast<QCPAxisRect**>(_v) = _t->axisRect(); break;
case 2: *reinterpret_cast<enum ScaleType*>(_v) = _t->scaleType(); break;
case 3: *reinterpret_cast<QCPRange*>(_v) = _t->range(); break;
case 4: *reinterpret_cast<bool*>(_v) = _t->rangeReversed(); break;
case 5: *reinterpret_cast<QSharedPointer<QCPAxisTicker>*>(_v) = _t->ticker(); break;
case 6: *reinterpret_cast<bool*>(_v) = _t->ticks(); break;
case 7: *reinterpret_cast<bool*>(_v) = _t->tickLabels(); break;
case 8: *reinterpret_cast<int*>(_v) = _t->tickLabelPadding(); break;
case 9: *reinterpret_cast<QFont*>(_v) = _t->tickLabelFont(); break;
case 10: *reinterpret_cast<QColor*>(_v) = _t->tickLabelColor(); break;
case 11: *reinterpret_cast<double*>(_v) = _t->tickLabelRotation(); break;
case 12: *reinterpret_cast<enum LabelSide*>(_v) = _t->tickLabelSide(); break;
case 13: *reinterpret_cast<QString*>(_v) = _t->numberFormat(); break;
case 14: *reinterpret_cast<int*>(_v) = _t->numberPrecision(); break;
case 15: *reinterpret_cast<QList<double>*>(_v) = _t->tickVector(); break;
case 16: *reinterpret_cast<QList<QString>*>(_v) = _t->tickVectorLabels(); break;
case 17: *reinterpret_cast<int*>(_v) = _t->tickLengthIn(); break;
case 18: *reinterpret_cast<int*>(_v) = _t->tickLengthOut(); break;
case 19: *reinterpret_cast<bool*>(_v) = _t->subTicks(); break;
case 20: *reinterpret_cast<int*>(_v) = _t->subTickLengthIn(); break;
case 21: *reinterpret_cast<int*>(_v) = _t->subTickLengthOut(); break;
case 22: *reinterpret_cast<QPen*>(_v) = _t->basePen(); break;
case 23: *reinterpret_cast<QPen*>(_v) = _t->tickPen(); break;
case 24: *reinterpret_cast<QPen*>(_v) = _t->subTickPen(); break;
case 25: *reinterpret_cast<QFont*>(_v) = _t->labelFont(); break;
case 26: *reinterpret_cast<QColor*>(_v) = _t->labelColor(); break;
case 27: *reinterpret_cast<QString*>(_v) = _t->label(); break;
case 28: *reinterpret_cast<int*>(_v) = _t->labelPadding(); break;
case 29: *reinterpret_cast<int*>(_v) = _t->padding(); break;
case 30: *reinterpret_cast<int*>(_v) = _t->offset(); break;
case 31: QtMocHelpers::assignFlags<SelectableParts>(_v, _t->selectedParts()); break;
case 32: QtMocHelpers::assignFlags<SelectableParts>(_v, _t->selectableParts()); break;
case 33: *reinterpret_cast<QFont*>(_v) = _t->selectedTickLabelFont(); break;
case 34: *reinterpret_cast<QFont*>(_v) = _t->selectedLabelFont(); break;
case 35: *reinterpret_cast<QColor*>(_v) = _t->selectedTickLabelColor(); break;
case 36: *reinterpret_cast<QColor*>(_v) = _t->selectedLabelColor(); break;
case 37: *reinterpret_cast<QPen*>(_v) = _t->selectedBasePen(); break;
case 38: *reinterpret_cast<QPen*>(_v) = _t->selectedTickPen(); break;
case 39: *reinterpret_cast<QPen*>(_v) = _t->selectedSubTickPen(); break;
case 40: *reinterpret_cast<QCPLineEnding*>(_v) = _t->lowerEnding(); break;
case 41: *reinterpret_cast<QCPLineEnding*>(_v) = _t->upperEnding(); break;
case 42: *reinterpret_cast<QCPGrid**>(_v) = _t->grid(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 2: _t->setScaleType(*reinterpret_cast<enum ScaleType*>(_v)); break;
case 3: _t->setRange(*reinterpret_cast<QCPRange*>(_v)); break;
case 4: _t->setRangeReversed(*reinterpret_cast<bool*>(_v)); break;
case 5: _t->setTicker(*reinterpret_cast<QSharedPointer<QCPAxisTicker>*>(_v)); break;
case 6: _t->setTicks(*reinterpret_cast<bool*>(_v)); break;
case 7: _t->setTickLabels(*reinterpret_cast<bool*>(_v)); break;
case 8: _t->setTickLabelPadding(*reinterpret_cast<int*>(_v)); break;
case 9: _t->setTickLabelFont(*reinterpret_cast<QFont*>(_v)); break;
case 10: _t->setTickLabelColor(*reinterpret_cast<QColor*>(_v)); break;
case 11: _t->setTickLabelRotation(*reinterpret_cast<double*>(_v)); break;
case 12: _t->setTickLabelSide(*reinterpret_cast<enum LabelSide*>(_v)); break;
case 13: _t->setNumberFormat(*reinterpret_cast<QString*>(_v)); break;
case 14: _t->setNumberPrecision(*reinterpret_cast<int*>(_v)); break;
case 17: _t->setTickLengthIn(*reinterpret_cast<int*>(_v)); break;
case 18: _t->setTickLengthOut(*reinterpret_cast<int*>(_v)); break;
case 19: _t->setSubTicks(*reinterpret_cast<bool*>(_v)); break;
case 20: _t->setSubTickLengthIn(*reinterpret_cast<int*>(_v)); break;
case 21: _t->setSubTickLengthOut(*reinterpret_cast<int*>(_v)); break;
case 22: _t->setBasePen(*reinterpret_cast<QPen*>(_v)); break;
case 23: _t->setTickPen(*reinterpret_cast<QPen*>(_v)); break;
case 24: _t->setSubTickPen(*reinterpret_cast<QPen*>(_v)); break;
case 25: _t->setLabelFont(*reinterpret_cast<QFont*>(_v)); break;
case 26: _t->setLabelColor(*reinterpret_cast<QColor*>(_v)); break;
case 27: _t->setLabel(*reinterpret_cast<QString*>(_v)); break;
case 28: _t->setLabelPadding(*reinterpret_cast<int*>(_v)); break;
case 29: _t->setPadding(*reinterpret_cast<int*>(_v)); break;
case 30: _t->setOffset(*reinterpret_cast<int*>(_v)); break;
case 31: _t->setSelectedParts(*reinterpret_cast<SelectableParts*>(_v)); break;
case 32: _t->setSelectableParts(*reinterpret_cast<SelectableParts*>(_v)); break;
case 33: _t->setSelectedTickLabelFont(*reinterpret_cast<QFont*>(_v)); break;
case 34: _t->setSelectedLabelFont(*reinterpret_cast<QFont*>(_v)); break;
case 35: _t->setSelectedTickLabelColor(*reinterpret_cast<QColor*>(_v)); break;
case 36: _t->setSelectedLabelColor(*reinterpret_cast<QColor*>(_v)); break;
case 37: _t->setSelectedBasePen(*reinterpret_cast<QPen*>(_v)); break;
case 38: _t->setSelectedTickPen(*reinterpret_cast<QPen*>(_v)); break;
case 39: _t->setSelectedSubTickPen(*reinterpret_cast<QPen*>(_v)); break;
case 40: _t->setLowerEnding(*reinterpret_cast<QCPLineEnding*>(_v)); break;
case 41: _t->setUpperEnding(*reinterpret_cast<QCPLineEnding*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPAxis::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPAxis::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPAxisE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPAxis::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 43;
}
return _id;
}
// SIGNAL 0
void QCPAxis::rangeChanged(const QCPRange & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPAxis::rangeChanged(const QCPRange & _t1, const QCPRange & _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}
// SIGNAL 2
void QCPAxis::scaleTypeChanged(QCPAxis::ScaleType _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
// SIGNAL 3
void QCPAxis::selectionChanged(const QCPAxis::SelectableParts & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
// SIGNAL 4
void QCPAxis::selectableChanged(const QCPAxis::SelectableParts & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN15QCPScatterStyleE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPScatterStyle::qt_create_metaobjectdata<qt_meta_tag_ZN15QCPScatterStyleE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPScatterStyle",
"ScatterProperty",
"spNone",
"spPen",
"spBrush",
"spSize",
"spShape",
"spAll",
"ScatterProperties",
"ScatterShape",
"ssNone",
"ssDot",
"ssCross",
"ssPlus",
"ssCircle",
"ssDisc",
"ssSquare",
"ssDiamond",
"ssStar",
"ssTriangle",
"ssTriangleInverted",
"ssCrossSquare",
"ssPlusSquare",
"ssCrossCircle",
"ssPlusCircle",
"ssPeace",
"ssPixmap",
"ssCustom"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'ScatterProperty'
QtMocHelpers::EnumData<enum ScatterProperty>(1, 1, QMC::EnumFlags{}).add({
{ 2, ScatterProperty::spNone },
{ 3, ScatterProperty::spPen },
{ 4, ScatterProperty::spBrush },
{ 5, ScatterProperty::spSize },
{ 6, ScatterProperty::spShape },
{ 7, ScatterProperty::spAll },
}),
// enum 'ScatterProperties'
QtMocHelpers::EnumData<ScatterProperties>(8, 1, QMC::EnumFlags{}).add({
{ 2, ScatterProperty::spNone },
{ 3, ScatterProperty::spPen },
{ 4, ScatterProperty::spBrush },
{ 5, ScatterProperty::spSize },
{ 6, ScatterProperty::spShape },
{ 7, ScatterProperty::spAll },
}),
// enum 'ScatterShape'
QtMocHelpers::EnumData<enum ScatterShape>(9, 9, QMC::EnumFlags{}).add({
{ 10, ScatterShape::ssNone },
{ 11, ScatterShape::ssDot },
{ 12, ScatterShape::ssCross },
{ 13, ScatterShape::ssPlus },
{ 14, ScatterShape::ssCircle },
{ 15, ScatterShape::ssDisc },
{ 16, ScatterShape::ssSquare },
{ 17, ScatterShape::ssDiamond },
{ 18, ScatterShape::ssStar },
{ 19, ScatterShape::ssTriangle },
{ 20, ScatterShape::ssTriangleInverted },
{ 21, ScatterShape::ssCrossSquare },
{ 22, ScatterShape::ssPlusSquare },
{ 23, ScatterShape::ssCrossCircle },
{ 24, ScatterShape::ssPlusCircle },
{ 25, ScatterShape::ssPeace },
{ 26, ScatterShape::ssPixmap },
{ 27, ScatterShape::ssCustom },
}),
};
return QtMocHelpers::metaObjectData<QCPScatterStyle, qt_meta_tag_ZN15QCPScatterStyleE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPScatterStyle::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPScatterStyleE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPScatterStyleE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15QCPScatterStyleE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN21QCPSelectionDecoratorE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPSelectionDecorator::qt_create_metaobjectdata<qt_meta_tag_ZN21QCPSelectionDecoratorE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPSelectionDecorator"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPSelectionDecorator, qt_meta_tag_ZN21QCPSelectionDecoratorE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPSelectionDecorator::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QCPSelectionDecoratorE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QCPSelectionDecoratorE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QCPSelectionDecoratorE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN20QCPAbstractPlottableE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAbstractPlottable::qt_create_metaobjectdata<qt_meta_tag_ZN20QCPAbstractPlottableE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAbstractPlottable",
"selectionChanged",
"",
"selected",
"QCPDataSelection",
"selection",
"selectableChanged",
"QCP::SelectionType",
"selectable",
"setSelectable",
"setSelection",
"name",
"antialiasedFill",
"antialiasedScatters",
"pen",
"brush",
"keyAxis",
"QCPAxis*",
"valueAxis",
"selectionDecorator",
"QCPSelectionDecorator*"
};
QtMocHelpers::UintData qt_methods {
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(const QCPDataSelection &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 4, 5 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(QCP::SelectionType)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setSelectable'
QtMocHelpers::SlotData<void(QCP::SelectionType)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setSelection'
QtMocHelpers::SlotData<void(QCPDataSelection)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 4, 5 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'name'
QtMocHelpers::PropertyData<QString>(11, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'antialiasedFill'
QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'antialiasedScatters'
QtMocHelpers::PropertyData<bool>(13, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'pen'
QtMocHelpers::PropertyData<QPen>(14, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brush'
QtMocHelpers::PropertyData<QBrush>(15, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'keyAxis'
QtMocHelpers::PropertyData<QCPAxis*>(16, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'valueAxis'
QtMocHelpers::PropertyData<QCPAxis*>(18, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'selectable'
QtMocHelpers::PropertyData<QCP::SelectionType>(8, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
// property 'selection'
QtMocHelpers::PropertyData<QCPDataSelection>(5, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
// property 'selectionDecorator'
QtMocHelpers::PropertyData<QCPSelectionDecorator*>(19, 0x80000000 | 20, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPAbstractPlottable, qt_meta_tag_ZN20QCPAbstractPlottableE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN20QCPAbstractPlottableE[] = {
QMetaObject::SuperData::link<QCP::staticMetaObject>(),
nullptr
};
Q_CONSTINIT const QMetaObject QCPAbstractPlottable::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QCPAbstractPlottableE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QCPAbstractPlottableE_t>.data,
qt_static_metacall,
qt_meta_extradata_ZN20QCPAbstractPlottableE,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QCPAbstractPlottableE_t>.metaTypes,
nullptr
} };
void QCPAbstractPlottable::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPAbstractPlottable *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<QCPDataSelection>>(_a[1]))); break;
case 2: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<QCP::SelectionType>>(_a[1]))); break;
case 3: _t->setSelectable((*reinterpret_cast< std::add_pointer_t<QCP::SelectionType>>(_a[1]))); break;
case 4: _t->setSelection((*reinterpret_cast< std::add_pointer_t<QCPDataSelection>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 1:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPDataSelection >(); break;
}
break;
case 4:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPDataSelection >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPAbstractPlottable::*)(bool )>(_a, &QCPAbstractPlottable::selectionChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAbstractPlottable::*)(const QCPDataSelection & )>(_a, &QCPAbstractPlottable::selectionChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAbstractPlottable::*)(QCP::SelectionType )>(_a, &QCPAbstractPlottable::selectableChanged, 2))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 6:
case 5:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis* >(); break;
case 8:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPDataSelection >(); break;
case 9:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPSelectionDecorator* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QString*>(_v) = _t->name(); break;
case 1: *reinterpret_cast<bool*>(_v) = _t->antialiasedFill(); break;
case 2: *reinterpret_cast<bool*>(_v) = _t->antialiasedScatters(); break;
case 3: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 4: *reinterpret_cast<QBrush*>(_v) = _t->brush(); break;
case 5: *reinterpret_cast<QCPAxis**>(_v) = _t->keyAxis(); break;
case 6: *reinterpret_cast<QCPAxis**>(_v) = _t->valueAxis(); break;
case 7: *reinterpret_cast<QCP::SelectionType*>(_v) = _t->selectable(); break;
case 8: *reinterpret_cast<QCPDataSelection*>(_v) = _t->selection(); break;
case 9: *reinterpret_cast<QCPSelectionDecorator**>(_v) = _t->selectionDecorator(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setName(*reinterpret_cast<QString*>(_v)); break;
case 1: _t->setAntialiasedFill(*reinterpret_cast<bool*>(_v)); break;
case 2: _t->setAntialiasedScatters(*reinterpret_cast<bool*>(_v)); break;
case 3: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 4: _t->setBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 5: _t->setKeyAxis(*reinterpret_cast<QCPAxis**>(_v)); break;
case 6: _t->setValueAxis(*reinterpret_cast<QCPAxis**>(_v)); break;
case 7: _t->setSelectable(*reinterpret_cast<QCP::SelectionType*>(_v)); break;
case 8: _t->setSelection(*reinterpret_cast<QCPDataSelection*>(_v)); break;
case 9: _t->setSelectionDecorator(*reinterpret_cast<QCPSelectionDecorator**>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPAbstractPlottable::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPAbstractPlottable::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QCPAbstractPlottableE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPAbstractPlottable::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 10;
}
return _id;
}
// SIGNAL 0
void QCPAbstractPlottable::selectionChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPAbstractPlottable::selectionChanged(const QCPDataSelection & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void QCPAbstractPlottable::selectableChanged(QCP::SelectionType _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN13QCPItemAnchorE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemAnchor::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPItemAnchorE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemAnchor"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemAnchor, qt_meta_tag_ZN13QCPItemAnchorE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemAnchor::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemAnchorE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemAnchorE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPItemAnchorE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN15QCPItemPositionE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemPosition::qt_create_metaobjectdata<qt_meta_tag_ZN15QCPItemPositionE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemPosition",
"PositionType",
"ptAbsolute",
"ptViewportRatio",
"ptAxisRectRatio",
"ptPlotCoords"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'PositionType'
QtMocHelpers::EnumData<enum PositionType>(1, 1, QMC::EnumFlags{}).add({
{ 2, PositionType::ptAbsolute },
{ 3, PositionType::ptViewportRatio },
{ 4, PositionType::ptAxisRectRatio },
{ 5, PositionType::ptPlotCoords },
}),
};
return QtMocHelpers::metaObjectData<QCPItemPosition, qt_meta_tag_ZN15QCPItemPositionE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemPosition::staticMetaObject = { {
QtPrivate::MetaObjectForType<QCPItemAnchor>::value,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPItemPositionE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPItemPositionE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15QCPItemPositionE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN15QCPAbstractItemE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAbstractItem::qt_create_metaobjectdata<qt_meta_tag_ZN15QCPAbstractItemE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAbstractItem",
"selectionChanged",
"",
"selected",
"selectableChanged",
"selectable",
"setSelectable",
"setSelected",
"clipToAxisRect",
"clipAxisRect",
"QCPAxisRect*"
};
QtMocHelpers::UintData qt_methods {
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 5 },
}}),
// Slot 'setSelectable'
QtMocHelpers::SlotData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 5 },
}}),
// Slot 'setSelected'
QtMocHelpers::SlotData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'clipToAxisRect'
QtMocHelpers::PropertyData<bool>(8, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'clipAxisRect'
QtMocHelpers::PropertyData<QCPAxisRect*>(9, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'selectable'
QtMocHelpers::PropertyData<bool>(5, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
// property 'selected'
QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPAbstractItem, qt_meta_tag_ZN15QCPAbstractItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAbstractItem::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPAbstractItemE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPAbstractItemE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15QCPAbstractItemE_t>.metaTypes,
nullptr
} };
void QCPAbstractItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPAbstractItem *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 2: _t->setSelectable((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 3: _t->setSelected((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPAbstractItem::*)(bool )>(_a, &QCPAbstractItem::selectionChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAbstractItem::*)(bool )>(_a, &QCPAbstractItem::selectableChanged, 1))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 1:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxisRect* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<bool*>(_v) = _t->clipToAxisRect(); break;
case 1: *reinterpret_cast<QCPAxisRect**>(_v) = _t->clipAxisRect(); break;
case 2: *reinterpret_cast<bool*>(_v) = _t->selectable(); break;
case 3: *reinterpret_cast<bool*>(_v) = _t->selected(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setClipToAxisRect(*reinterpret_cast<bool*>(_v)); break;
case 1: _t->setClipAxisRect(*reinterpret_cast<QCPAxisRect**>(_v)); break;
case 2: _t->setSelectable(*reinterpret_cast<bool*>(_v)); break;
case 3: _t->setSelected(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPAbstractItem::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPAbstractItem::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15QCPAbstractItemE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPAbstractItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 4;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
return _id;
}
// SIGNAL 0
void QCPAbstractItem::selectionChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPAbstractItem::selectableChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN11QCustomPlotE_t {};
} // unnamed namespace
template <> constexpr inline auto QCustomPlot::qt_create_metaobjectdata<qt_meta_tag_ZN11QCustomPlotE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCustomPlot",
"mouseDoubleClick",
"",
"QMouseEvent*",
"event",
"mousePress",
"mouseMove",
"mouseRelease",
"mouseWheel",
"QWheelEvent*",
"plottableClick",
"QCPAbstractPlottable*",
"plottable",
"dataIndex",
"plottableDoubleClick",
"itemClick",
"QCPAbstractItem*",
"item",
"itemDoubleClick",
"axisClick",
"QCPAxis*",
"axis",
"QCPAxis::SelectablePart",
"part",
"axisDoubleClick",
"legendClick",
"QCPLegend*",
"legend",
"QCPAbstractLegendItem*",
"legendDoubleClick",
"selectionChangedByUser",
"beforeReplot",
"afterLayout",
"afterReplot",
"rescaleAxes",
"onlyVisiblePlottables",
"deselectAll",
"replot",
"QCustomPlot::RefreshPriority",
"refreshPriority",
"processRectSelection",
"rect",
"processRectZoom",
"processPointSelection",
"viewport",
"background",
"backgroundScaled",
"backgroundScaledMode",
"Qt::AspectRatioMode",
"plotLayout",
"QCPLayoutGrid*",
"autoAddPlottableToLegend",
"selectionTolerance",
"noAntialiasingOnDrag",
"multiSelectModifier",
"Qt::KeyboardModifier",
"openGl",
"LayerInsertMode",
"limBelow",
"limAbove",
"RefreshPriority",
"rpImmediateRefresh",
"rpQueuedRefresh",
"rpRefreshHint",
"rpQueuedReplot"
};
QtMocHelpers::UintData qt_methods {
// Signal 'mouseDoubleClick'
QtMocHelpers::SignalData<void(QMouseEvent *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'mousePress'
QtMocHelpers::SignalData<void(QMouseEvent *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'mouseMove'
QtMocHelpers::SignalData<void(QMouseEvent *)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'mouseRelease'
QtMocHelpers::SignalData<void(QMouseEvent *)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'mouseWheel'
QtMocHelpers::SignalData<void(QWheelEvent *)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 9, 4 },
}}),
// Signal 'plottableClick'
QtMocHelpers::SignalData<void(QCPAbstractPlottable *, int, QMouseEvent *)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 11, 12 }, { QMetaType::Int, 13 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'plottableDoubleClick'
QtMocHelpers::SignalData<void(QCPAbstractPlottable *, int, QMouseEvent *)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 11, 12 }, { QMetaType::Int, 13 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'itemClick'
QtMocHelpers::SignalData<void(QCPAbstractItem *, QMouseEvent *)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 16, 17 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'itemDoubleClick'
QtMocHelpers::SignalData<void(QCPAbstractItem *, QMouseEvent *)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 16, 17 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'axisClick'
QtMocHelpers::SignalData<void(QCPAxis *, QCPAxis::SelectablePart, QMouseEvent *)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 20, 21 }, { 0x80000000 | 22, 23 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'axisDoubleClick'
QtMocHelpers::SignalData<void(QCPAxis *, QCPAxis::SelectablePart, QMouseEvent *)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 20, 21 }, { 0x80000000 | 22, 23 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'legendClick'
QtMocHelpers::SignalData<void(QCPLegend *, QCPAbstractLegendItem *, QMouseEvent *)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 26, 27 }, { 0x80000000 | 28, 17 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'legendDoubleClick'
QtMocHelpers::SignalData<void(QCPLegend *, QCPAbstractLegendItem *, QMouseEvent *)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 26, 27 }, { 0x80000000 | 28, 17 }, { 0x80000000 | 3, 4 },
}}),
// Signal 'selectionChangedByUser'
QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'beforeReplot'
QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'afterLayout'
QtMocHelpers::SignalData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'afterReplot'
QtMocHelpers::SignalData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'rescaleAxes'
QtMocHelpers::SlotData<void(bool)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 35 },
}}),
// Slot 'rescaleAxes'
QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
// Slot 'deselectAll'
QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'replot'
QtMocHelpers::SlotData<void(QCustomPlot::RefreshPriority)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 38, 39 },
}}),
// Slot 'replot'
QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
// Slot 'processRectSelection'
QtMocHelpers::SlotData<void(QRect, QMouseEvent *)>(40, 2, QMC::AccessProtected, QMetaType::Void, {{
{ QMetaType::QRect, 41 }, { 0x80000000 | 3, 4 },
}}),
// Slot 'processRectZoom'
QtMocHelpers::SlotData<void(QRect, QMouseEvent *)>(42, 2, QMC::AccessProtected, QMetaType::Void, {{
{ QMetaType::QRect, 41 }, { 0x80000000 | 3, 4 },
}}),
// Slot 'processPointSelection'
QtMocHelpers::SlotData<void(QMouseEvent *)>(43, 2, QMC::AccessProtected, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'viewport'
QtMocHelpers::PropertyData<QRect>(44, QMetaType::QRect, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'background'
QtMocHelpers::PropertyData<QPixmap>(45, QMetaType::QPixmap, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'backgroundScaled'
QtMocHelpers::PropertyData<bool>(46, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'backgroundScaledMode'
QtMocHelpers::PropertyData<Qt::AspectRatioMode>(47, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'plotLayout'
QtMocHelpers::PropertyData<QCPLayoutGrid*>(49, 0x80000000 | 50, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'autoAddPlottableToLegend'
QtMocHelpers::PropertyData<bool>(51, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectionTolerance'
QtMocHelpers::PropertyData<int>(52, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'noAntialiasingOnDrag'
QtMocHelpers::PropertyData<bool>(53, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'multiSelectModifier'
QtMocHelpers::PropertyData<Qt::KeyboardModifier>(54, 0x80000000 | 55, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'openGl'
QtMocHelpers::PropertyData<bool>(56, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'LayerInsertMode'
QtMocHelpers::EnumData<enum LayerInsertMode>(57, 57, QMC::EnumFlags{}).add({
{ 58, LayerInsertMode::limBelow },
{ 59, LayerInsertMode::limAbove },
}),
// enum 'RefreshPriority'
QtMocHelpers::EnumData<enum RefreshPriority>(60, 60, QMC::EnumFlags{}).add({
{ 61, RefreshPriority::rpImmediateRefresh },
{ 62, RefreshPriority::rpQueuedRefresh },
{ 63, RefreshPriority::rpRefreshHint },
{ 64, RefreshPriority::rpQueuedReplot },
}),
};
return QtMocHelpers::metaObjectData<QCustomPlot, qt_meta_tag_ZN11QCustomPlotE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCustomPlot::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCustomPlotE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCustomPlotE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QCustomPlotE_t>.metaTypes,
nullptr
} };
void QCustomPlot::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCustomPlot *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->mouseDoubleClick((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 1: _t->mousePress((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 2: _t->mouseMove((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 3: _t->mouseRelease((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 4: _t->mouseWheel((*reinterpret_cast< std::add_pointer_t<QWheelEvent*>>(_a[1]))); break;
case 5: _t->plottableClick((*reinterpret_cast< std::add_pointer_t<QCPAbstractPlottable*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[3]))); break;
case 6: _t->plottableDoubleClick((*reinterpret_cast< std::add_pointer_t<QCPAbstractPlottable*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[3]))); break;
case 7: _t->itemClick((*reinterpret_cast< std::add_pointer_t<QCPAbstractItem*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[2]))); break;
case 8: _t->itemDoubleClick((*reinterpret_cast< std::add_pointer_t<QCPAbstractItem*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[2]))); break;
case 9: _t->axisClick((*reinterpret_cast< std::add_pointer_t<QCPAxis*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectablePart>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[3]))); break;
case 10: _t->axisDoubleClick((*reinterpret_cast< std::add_pointer_t<QCPAxis*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectablePart>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[3]))); break;
case 11: _t->legendClick((*reinterpret_cast< std::add_pointer_t<QCPLegend*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPAbstractLegendItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[3]))); break;
case 12: _t->legendDoubleClick((*reinterpret_cast< std::add_pointer_t<QCPLegend*>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPAbstractLegendItem*>>(_a[2])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[3]))); break;
case 13: _t->selectionChangedByUser(); break;
case 14: _t->beforeReplot(); break;
case 15: _t->afterLayout(); break;
case 16: _t->afterReplot(); break;
case 17: _t->rescaleAxes((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 18: _t->rescaleAxes(); break;
case 19: _t->deselectAll(); break;
case 20: _t->replot((*reinterpret_cast< std::add_pointer_t<QCustomPlot::RefreshPriority>>(_a[1]))); break;
case 21: _t->replot(); break;
case 22: _t->processRectSelection((*reinterpret_cast< std::add_pointer_t<QRect>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[2]))); break;
case 23: _t->processRectZoom((*reinterpret_cast< std::add_pointer_t<QRect>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[2]))); break;
case 24: _t->processPointSelection((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 5:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAbstractPlottable* >(); break;
}
break;
case 6:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAbstractPlottable* >(); break;
}
break;
case 7:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAbstractItem* >(); break;
}
break;
case 8:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAbstractItem* >(); break;
}
break;
case 9:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis* >(); break;
case 1:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::SelectablePart >(); break;
}
break;
case 10:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis* >(); break;
case 1:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::SelectablePart >(); break;
}
break;
case 11:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 1:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAbstractLegendItem* >(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPLegend* >(); break;
}
break;
case 12:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 1:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAbstractLegendItem* >(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPLegend* >(); break;
}
break;
case 20:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCustomPlot::RefreshPriority >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QMouseEvent * )>(_a, &QCustomPlot::mouseDoubleClick, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QMouseEvent * )>(_a, &QCustomPlot::mousePress, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QMouseEvent * )>(_a, &QCustomPlot::mouseMove, 2))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QMouseEvent * )>(_a, &QCustomPlot::mouseRelease, 3))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QWheelEvent * )>(_a, &QCustomPlot::mouseWheel, 4))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPAbstractPlottable * , int , QMouseEvent * )>(_a, &QCustomPlot::plottableClick, 5))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPAbstractPlottable * , int , QMouseEvent * )>(_a, &QCustomPlot::plottableDoubleClick, 6))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPAbstractItem * , QMouseEvent * )>(_a, &QCustomPlot::itemClick, 7))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPAbstractItem * , QMouseEvent * )>(_a, &QCustomPlot::itemDoubleClick, 8))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPAxis * , QCPAxis::SelectablePart , QMouseEvent * )>(_a, &QCustomPlot::axisClick, 9))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPAxis * , QCPAxis::SelectablePart , QMouseEvent * )>(_a, &QCustomPlot::axisDoubleClick, 10))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPLegend * , QCPAbstractLegendItem * , QMouseEvent * )>(_a, &QCustomPlot::legendClick, 11))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)(QCPLegend * , QCPAbstractLegendItem * , QMouseEvent * )>(_a, &QCustomPlot::legendDoubleClick, 12))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)()>(_a, &QCustomPlot::selectionChangedByUser, 13))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)()>(_a, &QCustomPlot::beforeReplot, 14))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)()>(_a, &QCustomPlot::afterLayout, 15))
return;
if (QtMocHelpers::indexOfMethod<void (QCustomPlot::*)()>(_a, &QCustomPlot::afterReplot, 16))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 4:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLayoutGrid* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QRect*>(_v) = _t->viewport(); break;
case 1: *reinterpret_cast<QPixmap*>(_v) = _t->background(); break;
case 2: *reinterpret_cast<bool*>(_v) = _t->backgroundScaled(); break;
case 3: *reinterpret_cast<Qt::AspectRatioMode*>(_v) = _t->backgroundScaledMode(); break;
case 4: *reinterpret_cast<QCPLayoutGrid**>(_v) = _t->plotLayout(); break;
case 5: *reinterpret_cast<bool*>(_v) = _t->autoAddPlottableToLegend(); break;
case 6: *reinterpret_cast<int*>(_v) = _t->selectionTolerance(); break;
case 7: *reinterpret_cast<bool*>(_v) = _t->noAntialiasingOnDrag(); break;
case 8: *reinterpret_cast<Qt::KeyboardModifier*>(_v) = _t->multiSelectModifier(); break;
case 9: *reinterpret_cast<bool*>(_v) = _t->openGl(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setViewport(*reinterpret_cast<QRect*>(_v)); break;
case 1: _t->setBackground(*reinterpret_cast<QPixmap*>(_v)); break;
case 2: _t->setBackgroundScaled(*reinterpret_cast<bool*>(_v)); break;
case 3: _t->setBackgroundScaledMode(*reinterpret_cast<Qt::AspectRatioMode*>(_v)); break;
case 5: _t->setAutoAddPlottableToLegend(*reinterpret_cast<bool*>(_v)); break;
case 6: _t->setSelectionTolerance(*reinterpret_cast<int*>(_v)); break;
case 7: _t->setNoAntialiasingOnDrag(*reinterpret_cast<bool*>(_v)); break;
case 8: _t->setMultiSelectModifier(*reinterpret_cast<Qt::KeyboardModifier*>(_v)); break;
case 9: _t->setOpenGl(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCustomPlot::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCustomPlot::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCustomPlotE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int QCustomPlot::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 25)
qt_static_metacall(this, _c, _id, _a);
_id -= 25;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 25)
qt_static_metacall(this, _c, _id, _a);
_id -= 25;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 10;
}
return _id;
}
// SIGNAL 0
void QCustomPlot::mouseDoubleClick(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCustomPlot::mousePress(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void QCustomPlot::mouseMove(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
// SIGNAL 3
void QCustomPlot::mouseRelease(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
// SIGNAL 4
void QCustomPlot::mouseWheel(QWheelEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}
// SIGNAL 5
void QCustomPlot::plottableClick(QCPAbstractPlottable * _t1, int _t2, QMouseEvent * _t3)
{
QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2, _t3);
}
// SIGNAL 6
void QCustomPlot::plottableDoubleClick(QCPAbstractPlottable * _t1, int _t2, QMouseEvent * _t3)
{
QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2, _t3);
}
// SIGNAL 7
void QCustomPlot::itemClick(QCPAbstractItem * _t1, QMouseEvent * _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2);
}
// SIGNAL 8
void QCustomPlot::itemDoubleClick(QCPAbstractItem * _t1, QMouseEvent * _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2);
}
// SIGNAL 9
void QCustomPlot::axisClick(QCPAxis * _t1, QCPAxis::SelectablePart _t2, QMouseEvent * _t3)
{
QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1, _t2, _t3);
}
// SIGNAL 10
void QCustomPlot::axisDoubleClick(QCPAxis * _t1, QCPAxis::SelectablePart _t2, QMouseEvent * _t3)
{
QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2, _t3);
}
// SIGNAL 11
void QCustomPlot::legendClick(QCPLegend * _t1, QCPAbstractLegendItem * _t2, QMouseEvent * _t3)
{
QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3);
}
// SIGNAL 12
void QCustomPlot::legendDoubleClick(QCPLegend * _t1, QCPAbstractLegendItem * _t2, QMouseEvent * _t3)
{
QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2, _t3);
}
// SIGNAL 13
void QCustomPlot::selectionChangedByUser()
{
QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}
// SIGNAL 14
void QCustomPlot::beforeReplot()
{
QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}
// SIGNAL 15
void QCustomPlot::afterLayout()
{
QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}
// SIGNAL 16
void QCustomPlot::afterReplot()
{
QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}
namespace {
struct qt_meta_tag_ZN16QCPColorGradientE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPColorGradient::qt_create_metaobjectdata<qt_meta_tag_ZN16QCPColorGradientE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPColorGradient",
"ColorInterpolation",
"ciRGB",
"ciHSV",
"NanHandling",
"nhNone",
"nhLowestColor",
"nhHighestColor",
"nhTransparent",
"nhNanColor",
"GradientPreset",
"gpGrayscale",
"gpHot",
"gpCold",
"gpNight",
"gpCandy",
"gpGeography",
"gpIon",
"gpThermal",
"gpPolar",
"gpSpectrum",
"gpJet",
"gpHues"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'ColorInterpolation'
QtMocHelpers::EnumData<enum ColorInterpolation>(1, 1, QMC::EnumFlags{}).add({
{ 2, ColorInterpolation::ciRGB },
{ 3, ColorInterpolation::ciHSV },
}),
// enum 'NanHandling'
QtMocHelpers::EnumData<enum NanHandling>(4, 4, QMC::EnumFlags{}).add({
{ 5, NanHandling::nhNone },
{ 6, NanHandling::nhLowestColor },
{ 7, NanHandling::nhHighestColor },
{ 8, NanHandling::nhTransparent },
{ 9, NanHandling::nhNanColor },
}),
// enum 'GradientPreset'
QtMocHelpers::EnumData<enum GradientPreset>(10, 10, QMC::EnumFlags{}).add({
{ 11, GradientPreset::gpGrayscale },
{ 12, GradientPreset::gpHot },
{ 13, GradientPreset::gpCold },
{ 14, GradientPreset::gpNight },
{ 15, GradientPreset::gpCandy },
{ 16, GradientPreset::gpGeography },
{ 17, GradientPreset::gpIon },
{ 18, GradientPreset::gpThermal },
{ 19, GradientPreset::gpPolar },
{ 20, GradientPreset::gpSpectrum },
{ 21, GradientPreset::gpJet },
{ 22, GradientPreset::gpHues },
}),
};
return QtMocHelpers::metaObjectData<QCPColorGradient, qt_meta_tag_ZN16QCPColorGradientE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPColorGradient::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPColorGradientE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16QCPColorGradientE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16QCPColorGradientE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN28QCPSelectionDecoratorBracketE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPSelectionDecoratorBracket::qt_create_metaobjectdata<qt_meta_tag_ZN28QCPSelectionDecoratorBracketE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPSelectionDecoratorBracket",
"BracketStyle",
"bsSquareBracket",
"bsHalfEllipse",
"bsEllipse",
"bsPlus",
"bsUserStyle"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'BracketStyle'
QtMocHelpers::EnumData<enum BracketStyle>(1, 1, QMC::EnumFlags{}).add({
{ 2, BracketStyle::bsSquareBracket },
{ 3, BracketStyle::bsHalfEllipse },
{ 4, BracketStyle::bsEllipse },
{ 5, BracketStyle::bsPlus },
{ 6, BracketStyle::bsUserStyle },
}),
};
return QtMocHelpers::metaObjectData<QCPSelectionDecoratorBracket, qt_meta_tag_ZN28QCPSelectionDecoratorBracketE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPSelectionDecoratorBracket::staticMetaObject = { {
QtPrivate::MetaObjectForType<QCPSelectionDecorator>::value,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QCPSelectionDecoratorBracketE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QCPSelectionDecoratorBracketE_t>.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QCPSelectionDecoratorBracketE_t>.metaTypes,
nullptr
} };
namespace {
struct qt_meta_tag_ZN11QCPAxisRectE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAxisRect::qt_create_metaobjectdata<qt_meta_tag_ZN11QCPAxisRectE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAxisRect",
"background",
"backgroundScaled",
"backgroundScaledMode",
"Qt::AspectRatioMode",
"rangeDrag",
"Qt::Orientations",
"rangeZoom"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'background'
QtMocHelpers::PropertyData<QPixmap>(1, QMetaType::QPixmap, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'backgroundScaled'
QtMocHelpers::PropertyData<bool>(2, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'backgroundScaledMode'
QtMocHelpers::PropertyData<Qt::AspectRatioMode>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'rangeDrag'
QtMocHelpers::PropertyData<Qt::Orientations>(5, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'rangeZoom'
QtMocHelpers::PropertyData<Qt::Orientations>(7, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPAxisRect, qt_meta_tag_ZN11QCPAxisRectE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAxisRect::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPAxisRectE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPAxisRectE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QCPAxisRectE_t>.metaTypes,
nullptr
} };
void QCPAxisRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPAxisRect *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPixmap*>(_v) = _t->background(); break;
case 1: *reinterpret_cast<bool*>(_v) = _t->backgroundScaled(); break;
case 2: *reinterpret_cast<Qt::AspectRatioMode*>(_v) = _t->backgroundScaledMode(); break;
case 3: *reinterpret_cast<Qt::Orientations*>(_v) = _t->rangeDrag(); break;
case 4: *reinterpret_cast<Qt::Orientations*>(_v) = _t->rangeZoom(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setBackground(*reinterpret_cast<QPixmap*>(_v)); break;
case 1: _t->setBackgroundScaled(*reinterpret_cast<bool*>(_v)); break;
case 2: _t->setBackgroundScaledMode(*reinterpret_cast<Qt::AspectRatioMode*>(_v)); break;
case 3: _t->setRangeDrag(*reinterpret_cast<Qt::Orientations*>(_v)); break;
case 4: _t->setRangeZoom(*reinterpret_cast<Qt::Orientations*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPAxisRect::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPAxisRect::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPAxisRectE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutElement::qt_metacast(_clname);
}
int QCPAxisRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutElement::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN21QCPAbstractLegendItemE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPAbstractLegendItem::qt_create_metaobjectdata<qt_meta_tag_ZN21QCPAbstractLegendItemE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPAbstractLegendItem",
"selectionChanged",
"",
"selected",
"selectableChanged",
"selectable",
"setSelectable",
"setSelected",
"parentLegend",
"QCPLegend*",
"font",
"textColor",
"selectedFont",
"selectedTextColor"
};
QtMocHelpers::UintData qt_methods {
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 5 },
}}),
// Slot 'setSelectable'
QtMocHelpers::SlotData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 5 },
}}),
// Slot 'setSelected'
QtMocHelpers::SlotData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'parentLegend'
QtMocHelpers::PropertyData<QCPLegend*>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'font'
QtMocHelpers::PropertyData<QFont>(10, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'textColor'
QtMocHelpers::PropertyData<QColor>(11, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedFont'
QtMocHelpers::PropertyData<QFont>(12, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedTextColor'
QtMocHelpers::PropertyData<QColor>(13, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectable'
QtMocHelpers::PropertyData<bool>(5, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
// property 'selected'
QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPAbstractLegendItem, qt_meta_tag_ZN21QCPAbstractLegendItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPAbstractLegendItem::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QCPAbstractLegendItemE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QCPAbstractLegendItemE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QCPAbstractLegendItemE_t>.metaTypes,
nullptr
} };
void QCPAbstractLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPAbstractLegendItem *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 2: _t->setSelectable((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 3: _t->setSelected((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPAbstractLegendItem::*)(bool )>(_a, &QCPAbstractLegendItem::selectionChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPAbstractLegendItem::*)(bool )>(_a, &QCPAbstractLegendItem::selectableChanged, 1))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 0:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPLegend* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QCPLegend**>(_v) = _t->parentLegend(); break;
case 1: *reinterpret_cast<QFont*>(_v) = _t->font(); break;
case 2: *reinterpret_cast<QColor*>(_v) = _t->textColor(); break;
case 3: *reinterpret_cast<QFont*>(_v) = _t->selectedFont(); break;
case 4: *reinterpret_cast<QColor*>(_v) = _t->selectedTextColor(); break;
case 5: *reinterpret_cast<bool*>(_v) = _t->selectable(); break;
case 6: *reinterpret_cast<bool*>(_v) = _t->selected(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 1: _t->setFont(*reinterpret_cast<QFont*>(_v)); break;
case 2: _t->setTextColor(*reinterpret_cast<QColor*>(_v)); break;
case 3: _t->setSelectedFont(*reinterpret_cast<QFont*>(_v)); break;
case 4: _t->setSelectedTextColor(*reinterpret_cast<QColor*>(_v)); break;
case 5: _t->setSelectable(*reinterpret_cast<bool*>(_v)); break;
case 6: _t->setSelected(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPAbstractLegendItem::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPAbstractLegendItem::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QCPAbstractLegendItemE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutElement::qt_metacast(_clname);
}
int QCPAbstractLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutElement::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 4;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
}
return _id;
}
// SIGNAL 0
void QCPAbstractLegendItem::selectionChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPAbstractLegendItem::selectableChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN22QCPPlottableLegendItemE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPlottableLegendItem::qt_create_metaobjectdata<qt_meta_tag_ZN22QCPPlottableLegendItemE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPlottableLegendItem"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPPlottableLegendItem, qt_meta_tag_ZN22QCPPlottableLegendItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPlottableLegendItem::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractLegendItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCPPlottableLegendItemE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCPPlottableLegendItemE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QCPPlottableLegendItemE_t>.metaTypes,
nullptr
} };
void QCPPlottableLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPPlottableLegendItem *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *QCPPlottableLegendItem::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPPlottableLegendItem::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QCPPlottableLegendItemE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractLegendItem::qt_metacast(_clname);
}
int QCPPlottableLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractLegendItem::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN9QCPLegendE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPLegend::qt_create_metaobjectdata<qt_meta_tag_ZN9QCPLegendE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPLegend",
"selectionChanged",
"",
"QCPLegend::SelectableParts",
"parts",
"selectableChanged",
"setSelectableParts",
"SelectableParts",
"selectableParts",
"setSelectedParts",
"selectedParts",
"borderPen",
"brush",
"font",
"textColor",
"iconSize",
"iconTextPadding",
"iconBorderPen",
"selectedBorderPen",
"selectedIconBorderPen",
"selectedBrush",
"selectedFont",
"selectedTextColor",
"SelectablePart",
"spNone",
"spLegendBox",
"spItems"
};
QtMocHelpers::UintData qt_methods {
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(QCPLegend::SelectableParts)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(QCPLegend::SelectableParts)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Slot 'setSelectableParts'
QtMocHelpers::SlotData<void(const SelectableParts &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setSelectedParts'
QtMocHelpers::SlotData<void(const SelectableParts &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 10 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'borderPen'
QtMocHelpers::PropertyData<QPen>(11, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brush'
QtMocHelpers::PropertyData<QBrush>(12, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'font'
QtMocHelpers::PropertyData<QFont>(13, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'textColor'
QtMocHelpers::PropertyData<QColor>(14, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'iconSize'
QtMocHelpers::PropertyData<QSize>(15, QMetaType::QSize, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'iconTextPadding'
QtMocHelpers::PropertyData<int>(16, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'iconBorderPen'
QtMocHelpers::PropertyData<QPen>(17, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectableParts'
QtMocHelpers::PropertyData<SelectableParts>(8, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
// property 'selectedParts'
QtMocHelpers::PropertyData<SelectableParts>(10, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
// property 'selectedBorderPen'
QtMocHelpers::PropertyData<QPen>(18, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedIconBorderPen'
QtMocHelpers::PropertyData<QPen>(19, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedBrush'
QtMocHelpers::PropertyData<QBrush>(20, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedFont'
QtMocHelpers::PropertyData<QFont>(21, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedTextColor'
QtMocHelpers::PropertyData<QColor>(22, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'SelectablePart'
QtMocHelpers::EnumData<enum SelectablePart>(23, 23, QMC::EnumFlags{}).add({
{ 24, SelectablePart::spNone },
{ 25, SelectablePart::spLegendBox },
{ 26, SelectablePart::spItems },
}),
// enum 'SelectableParts'
QtMocHelpers::EnumData<SelectableParts>(7, 23, QMC::EnumFlags{}).add({
{ 24, SelectablePart::spNone },
{ 25, SelectablePart::spLegendBox },
{ 26, SelectablePart::spItems },
}),
};
return QtMocHelpers::metaObjectData<QCPLegend, qt_meta_tag_ZN9QCPLegendE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPLegend::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutGrid::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9QCPLegendE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9QCPLegendE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9QCPLegendE_t>.metaTypes,
nullptr
} };
void QCPLegend::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPLegend *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<QCPLegend::SelectableParts>>(_a[1]))); break;
case 1: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<QCPLegend::SelectableParts>>(_a[1]))); break;
case 2: _t->setSelectableParts((*reinterpret_cast< std::add_pointer_t<SelectableParts>>(_a[1]))); break;
case 3: _t->setSelectedParts((*reinterpret_cast< std::add_pointer_t<SelectableParts>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPLegend::*)(QCPLegend::SelectableParts )>(_a, &QCPLegend::selectionChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPLegend::*)(QCPLegend::SelectableParts )>(_a, &QCPLegend::selectableChanged, 1))
return;
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->borderPen(); break;
case 1: *reinterpret_cast<QBrush*>(_v) = _t->brush(); break;
case 2: *reinterpret_cast<QFont*>(_v) = _t->font(); break;
case 3: *reinterpret_cast<QColor*>(_v) = _t->textColor(); break;
case 4: *reinterpret_cast<QSize*>(_v) = _t->iconSize(); break;
case 5: *reinterpret_cast<int*>(_v) = _t->iconTextPadding(); break;
case 6: *reinterpret_cast<QPen*>(_v) = _t->iconBorderPen(); break;
case 7: QtMocHelpers::assignFlags<SelectableParts>(_v, _t->selectableParts()); break;
case 8: QtMocHelpers::assignFlags<SelectableParts>(_v, _t->selectedParts()); break;
case 9: *reinterpret_cast<QPen*>(_v) = _t->selectedBorderPen(); break;
case 10: *reinterpret_cast<QPen*>(_v) = _t->selectedIconBorderPen(); break;
case 11: *reinterpret_cast<QBrush*>(_v) = _t->selectedBrush(); break;
case 12: *reinterpret_cast<QFont*>(_v) = _t->selectedFont(); break;
case 13: *reinterpret_cast<QColor*>(_v) = _t->selectedTextColor(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setBorderPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 2: _t->setFont(*reinterpret_cast<QFont*>(_v)); break;
case 3: _t->setTextColor(*reinterpret_cast<QColor*>(_v)); break;
case 4: _t->setIconSize(*reinterpret_cast<QSize*>(_v)); break;
case 5: _t->setIconTextPadding(*reinterpret_cast<int*>(_v)); break;
case 6: _t->setIconBorderPen(*reinterpret_cast<QPen*>(_v)); break;
case 7: _t->setSelectableParts(*reinterpret_cast<SelectableParts*>(_v)); break;
case 8: _t->setSelectedParts(*reinterpret_cast<SelectableParts*>(_v)); break;
case 9: _t->setSelectedBorderPen(*reinterpret_cast<QPen*>(_v)); break;
case 10: _t->setSelectedIconBorderPen(*reinterpret_cast<QPen*>(_v)); break;
case 11: _t->setSelectedBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 12: _t->setSelectedFont(*reinterpret_cast<QFont*>(_v)); break;
case 13: _t->setSelectedTextColor(*reinterpret_cast<QColor*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPLegend::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPLegend::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9QCPLegendE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutGrid::qt_metacast(_clname);
}
int QCPLegend::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutGrid::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 4;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 14;
}
return _id;
}
// SIGNAL 0
void QCPLegend::selectionChanged(QCPLegend::SelectableParts _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPLegend::selectableChanged(QCPLegend::SelectableParts _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN14QCPTextElementE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPTextElement::qt_create_metaobjectdata<qt_meta_tag_ZN14QCPTextElementE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPTextElement",
"selectionChanged",
"",
"selected",
"selectableChanged",
"selectable",
"clicked",
"QMouseEvent*",
"event",
"doubleClicked",
"setSelectable",
"setSelected",
"text",
"font",
"textColor",
"selectedFont",
"selectedTextColor"
};
QtMocHelpers::UintData qt_methods {
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 5 },
}}),
// Signal 'clicked'
QtMocHelpers::SignalData<void(QMouseEvent *)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Signal 'doubleClicked'
QtMocHelpers::SignalData<void(QMouseEvent *)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setSelectable'
QtMocHelpers::SlotData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 5 },
}}),
// Slot 'setSelected'
QtMocHelpers::SlotData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'text'
QtMocHelpers::PropertyData<QString>(12, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'font'
QtMocHelpers::PropertyData<QFont>(13, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'textColor'
QtMocHelpers::PropertyData<QColor>(14, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedFont'
QtMocHelpers::PropertyData<QFont>(15, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedTextColor'
QtMocHelpers::PropertyData<QColor>(16, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectable'
QtMocHelpers::PropertyData<bool>(5, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
// property 'selected'
QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPTextElement, qt_meta_tag_ZN14QCPTextElementE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPTextElement::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPTextElementE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPTextElementE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QCPTextElementE_t>.metaTypes,
nullptr
} };
void QCPTextElement::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPTextElement *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 2: _t->clicked((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 3: _t->doubleClicked((*reinterpret_cast< std::add_pointer_t<QMouseEvent*>>(_a[1]))); break;
case 4: _t->setSelectable((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 5: _t->setSelected((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPTextElement::*)(bool )>(_a, &QCPTextElement::selectionChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPTextElement::*)(bool )>(_a, &QCPTextElement::selectableChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPTextElement::*)(QMouseEvent * )>(_a, &QCPTextElement::clicked, 2))
return;
if (QtMocHelpers::indexOfMethod<void (QCPTextElement::*)(QMouseEvent * )>(_a, &QCPTextElement::doubleClicked, 3))
return;
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QString*>(_v) = _t->text(); break;
case 1: *reinterpret_cast<QFont*>(_v) = _t->font(); break;
case 2: *reinterpret_cast<QColor*>(_v) = _t->textColor(); break;
case 3: *reinterpret_cast<QFont*>(_v) = _t->selectedFont(); break;
case 4: *reinterpret_cast<QColor*>(_v) = _t->selectedTextColor(); break;
case 5: *reinterpret_cast<bool*>(_v) = _t->selectable(); break;
case 6: *reinterpret_cast<bool*>(_v) = _t->selected(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setText(*reinterpret_cast<QString*>(_v)); break;
case 1: _t->setFont(*reinterpret_cast<QFont*>(_v)); break;
case 2: _t->setTextColor(*reinterpret_cast<QColor*>(_v)); break;
case 3: _t->setSelectedFont(*reinterpret_cast<QFont*>(_v)); break;
case 4: _t->setSelectedTextColor(*reinterpret_cast<QColor*>(_v)); break;
case 5: _t->setSelectable(*reinterpret_cast<bool*>(_v)); break;
case 6: _t->setSelected(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPTextElement::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPTextElement::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPTextElementE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutElement::qt_metacast(_clname);
}
int QCPTextElement::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutElement::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 6;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
}
return _id;
}
// SIGNAL 0
void QCPTextElement::selectionChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPTextElement::selectableChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void QCPTextElement::clicked(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
// SIGNAL 3
void QCPTextElement::doubleClicked(QMouseEvent * _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPColorScaleAxisRectPrivate::qt_create_metaobjectdata<qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPColorScaleAxisRectPrivate",
"axisSelectionChanged",
"",
"QCPAxis::SelectableParts",
"selectedParts",
"axisSelectableChanged",
"selectableParts"
};
QtMocHelpers::UintData qt_methods {
// Slot 'axisSelectionChanged'
QtMocHelpers::SlotData<void(QCPAxis::SelectableParts)>(1, 2, QMC::AccessProtected, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Slot 'axisSelectableChanged'
QtMocHelpers::SlotData<void(QCPAxis::SelectableParts)>(5, 2, QMC::AccessProtected, QMetaType::Void, {{
{ 0x80000000 | 3, 6 },
}}),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPColorScaleAxisRectPrivate, qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPColorScaleAxisRectPrivate::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAxisRect::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t>.metaTypes,
nullptr
} };
void QCPColorScaleAxisRectPrivate::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPColorScaleAxisRectPrivate *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->axisSelectionChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectableParts>>(_a[1]))); break;
case 1: _t->axisSelectableChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::SelectableParts>>(_a[1]))); break;
default: ;
}
}
}
const QMetaObject *QCPColorScaleAxisRectPrivate::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPColorScaleAxisRectPrivate::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QCPColorScaleAxisRectPrivateE_t>.strings))
return static_cast<void*>(this);
return QCPAxisRect::qt_metacast(_clname);
}
int QCPColorScaleAxisRectPrivate::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAxisRect::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 2;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN13QCPColorScaleE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPColorScale::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPColorScaleE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPColorScale",
"dataRangeChanged",
"",
"QCPRange",
"newRange",
"dataScaleTypeChanged",
"QCPAxis::ScaleType",
"scaleType",
"gradientChanged",
"QCPColorGradient",
"newGradient",
"setDataRange",
"dataRange",
"setDataScaleType",
"setGradient",
"gradient",
"type",
"QCPAxis::AxisType",
"dataScaleType",
"label",
"barWidth",
"rangeDrag",
"rangeZoom"
};
QtMocHelpers::UintData qt_methods {
// Signal 'dataRangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'dataScaleTypeChanged'
QtMocHelpers::SignalData<void(QCPAxis::ScaleType)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 6, 7 },
}}),
// Signal 'gradientChanged'
QtMocHelpers::SignalData<void(const QCPColorGradient &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 9, 10 },
}}),
// Slot 'setDataRange'
QtMocHelpers::SlotData<void(const QCPRange &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 12 },
}}),
// Slot 'setDataScaleType'
QtMocHelpers::SlotData<void(QCPAxis::ScaleType)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 6, 7 },
}}),
// Slot 'setGradient'
QtMocHelpers::SlotData<void(const QCPColorGradient &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 9, 15 },
}}),
};
QtMocHelpers::UintData qt_properties {
// property 'type'
QtMocHelpers::PropertyData<QCPAxis::AxisType>(16, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'dataRange'
QtMocHelpers::PropertyData<QCPRange>(12, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
// property 'dataScaleType'
QtMocHelpers::PropertyData<QCPAxis::ScaleType>(18, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
// property 'gradient'
QtMocHelpers::PropertyData<QCPColorGradient>(15, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
// property 'label'
QtMocHelpers::PropertyData<QString>(19, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'barWidth'
QtMocHelpers::PropertyData<int>(20, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'rangeDrag'
QtMocHelpers::PropertyData<bool>(21, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'rangeZoom'
QtMocHelpers::PropertyData<bool>(22, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPColorScale, qt_meta_tag_ZN13QCPColorScaleE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN13QCPColorScaleE[] = {
QMetaObject::SuperData::link<QCPAxis::staticMetaObject>(),
nullptr
};
Q_CONSTINIT const QMetaObject QCPColorScale::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPColorScaleE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPColorScaleE_t>.data,
qt_static_metacall,
qt_meta_extradata_ZN13QCPColorScaleE,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPColorScaleE_t>.metaTypes,
nullptr
} };
void QCPColorScale::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPColorScale *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->dataRangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 1: _t->dataScaleTypeChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::ScaleType>>(_a[1]))); break;
case 2: _t->gradientChanged((*reinterpret_cast< std::add_pointer_t<QCPColorGradient>>(_a[1]))); break;
case 3: _t->setDataRange((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 4: _t->setDataScaleType((*reinterpret_cast< std::add_pointer_t<QCPAxis::ScaleType>>(_a[1]))); break;
case 5: _t->setGradient((*reinterpret_cast< std::add_pointer_t<QCPColorGradient>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 1:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::ScaleType >(); break;
}
break;
case 4:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::ScaleType >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPColorScale::*)(const QCPRange & )>(_a, &QCPColorScale::dataRangeChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPColorScale::*)(QCPAxis::ScaleType )>(_a, &QCPColorScale::dataScaleTypeChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPColorScale::*)(const QCPColorGradient & )>(_a, &QCPColorScale::gradientChanged, 2))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 0:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::AxisType >(); break;
case 2:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::ScaleType >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QCPAxis::AxisType*>(_v) = _t->type(); break;
case 1: *reinterpret_cast<QCPRange*>(_v) = _t->dataRange(); break;
case 2: *reinterpret_cast<QCPAxis::ScaleType*>(_v) = _t->dataScaleType(); break;
case 3: *reinterpret_cast<QCPColorGradient*>(_v) = _t->gradient(); break;
case 4: *reinterpret_cast<QString*>(_v) = _t->label(); break;
case 5: *reinterpret_cast<int*>(_v) = _t->barWidth(); break;
case 6: *reinterpret_cast<bool*>(_v) = _t->rangeDrag(); break;
case 7: *reinterpret_cast<bool*>(_v) = _t->rangeZoom(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setType(*reinterpret_cast<QCPAxis::AxisType*>(_v)); break;
case 1: _t->setDataRange(*reinterpret_cast<QCPRange*>(_v)); break;
case 2: _t->setDataScaleType(*reinterpret_cast<QCPAxis::ScaleType*>(_v)); break;
case 3: _t->setGradient(*reinterpret_cast<QCPColorGradient*>(_v)); break;
case 4: _t->setLabel(*reinterpret_cast<QString*>(_v)); break;
case 5: _t->setBarWidth(*reinterpret_cast<int*>(_v)); break;
case 6: _t->setRangeDrag(*reinterpret_cast<bool*>(_v)); break;
case 7: _t->setRangeZoom(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPColorScale::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPColorScale::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPColorScaleE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutElement::qt_metacast(_clname);
}
int QCPColorScale::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutElement::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 6)
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
return _id;
}
// SIGNAL 0
void QCPColorScale::dataRangeChanged(const QCPRange & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPColorScale::dataScaleTypeChanged(QCPAxis::ScaleType _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void QCPColorScale::gradientChanged(const QCPColorGradient & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN8QCPGraphE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPGraph::qt_create_metaobjectdata<qt_meta_tag_ZN8QCPGraphE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPGraph",
"lineStyle",
"LineStyle",
"scatterStyle",
"QCPScatterStyle",
"scatterSkip",
"channelFillGraph",
"QCPGraph*",
"adaptiveSampling",
"lsNone",
"lsLine",
"lsStepLeft",
"lsStepRight",
"lsStepCenter",
"lsImpulse"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'lineStyle'
QtMocHelpers::PropertyData<enum LineStyle>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'scatterStyle'
QtMocHelpers::PropertyData<QCPScatterStyle>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'scatterSkip'
QtMocHelpers::PropertyData<int>(5, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'channelFillGraph'
QtMocHelpers::PropertyData<QCPGraph*>(6, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'adaptiveSampling'
QtMocHelpers::PropertyData<bool>(8, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'LineStyle'
QtMocHelpers::EnumData<enum LineStyle>(2, 2, QMC::EnumFlags{}).add({
{ 9, LineStyle::lsNone },
{ 10, LineStyle::lsLine },
{ 11, LineStyle::lsStepLeft },
{ 12, LineStyle::lsStepRight },
{ 13, LineStyle::lsStepCenter },
{ 14, LineStyle::lsImpulse },
}),
};
return QtMocHelpers::metaObjectData<QCPGraph, qt_meta_tag_ZN8QCPGraphE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPGraph::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable1D<QCPGraphData>::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPGraphE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPGraphE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8QCPGraphE_t>.metaTypes,
nullptr
} };
void QCPGraph::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPGraph *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 3:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGraph* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<enum LineStyle*>(_v) = _t->lineStyle(); break;
case 1: *reinterpret_cast<QCPScatterStyle*>(_v) = _t->scatterStyle(); break;
case 2: *reinterpret_cast<int*>(_v) = _t->scatterSkip(); break;
case 3: *reinterpret_cast<QCPGraph**>(_v) = _t->channelFillGraph(); break;
case 4: *reinterpret_cast<bool*>(_v) = _t->adaptiveSampling(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setLineStyle(*reinterpret_cast<enum LineStyle*>(_v)); break;
case 1: _t->setScatterStyle(*reinterpret_cast<QCPScatterStyle*>(_v)); break;
case 2: _t->setScatterSkip(*reinterpret_cast<int*>(_v)); break;
case 3: _t->setChannelFillGraph(*reinterpret_cast<QCPGraph**>(_v)); break;
case 4: _t->setAdaptiveSampling(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPGraph::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPGraph::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPGraphE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractPlottable1D<QCPGraphData>::qt_metacast(_clname);
}
int QCPGraph::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable1D<QCPGraphData>::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN8QCPCurveE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPCurve::qt_create_metaobjectdata<qt_meta_tag_ZN8QCPCurveE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPCurve",
"scatterStyle",
"QCPScatterStyle",
"scatterSkip",
"lineStyle",
"LineStyle",
"lsNone",
"lsLine"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'scatterStyle'
QtMocHelpers::PropertyData<QCPScatterStyle>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'scatterSkip'
QtMocHelpers::PropertyData<int>(3, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'lineStyle'
QtMocHelpers::PropertyData<enum LineStyle>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'LineStyle'
QtMocHelpers::EnumData<enum LineStyle>(5, 5, QMC::EnumFlags{}).add({
{ 6, LineStyle::lsNone },
{ 7, LineStyle::lsLine },
}),
};
return QtMocHelpers::metaObjectData<QCPCurve, qt_meta_tag_ZN8QCPCurveE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPCurve::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable1D<QCPCurveData>::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPCurveE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPCurveE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8QCPCurveE_t>.metaTypes,
nullptr
} };
void QCPCurve::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPCurve *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QCPScatterStyle*>(_v) = _t->scatterStyle(); break;
case 1: *reinterpret_cast<int*>(_v) = _t->scatterSkip(); break;
case 2: *reinterpret_cast<enum LineStyle*>(_v) = _t->lineStyle(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setScatterStyle(*reinterpret_cast<QCPScatterStyle*>(_v)); break;
case 1: _t->setScatterSkip(*reinterpret_cast<int*>(_v)); break;
case 2: _t->setLineStyle(*reinterpret_cast<enum LineStyle*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPCurve::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPCurve::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8QCPCurveE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractPlottable1D<QCPCurveData>::qt_metacast(_clname);
}
int QCPCurve::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable1D<QCPCurveData>::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 3;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN12QCPBarsGroupE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPBarsGroup::qt_create_metaobjectdata<qt_meta_tag_ZN12QCPBarsGroupE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPBarsGroup",
"spacingType",
"SpacingType",
"spacing",
"stAbsolute",
"stAxisRectRatio",
"stPlotCoords"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'spacingType'
QtMocHelpers::PropertyData<enum SpacingType>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'spacing'
QtMocHelpers::PropertyData<double>(3, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'SpacingType'
QtMocHelpers::EnumData<enum SpacingType>(2, 2, QMC::EnumFlags{}).add({
{ 4, SpacingType::stAbsolute },
{ 5, SpacingType::stAxisRectRatio },
{ 6, SpacingType::stPlotCoords },
}),
};
return QtMocHelpers::metaObjectData<QCPBarsGroup, qt_meta_tag_ZN12QCPBarsGroupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPBarsGroup::staticMetaObject = { {
QMetaObject::SuperData::link<QObject::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPBarsGroupE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPBarsGroupE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QCPBarsGroupE_t>.metaTypes,
nullptr
} };
void QCPBarsGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPBarsGroup *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<enum SpacingType*>(_v) = _t->spacingType(); break;
case 1: *reinterpret_cast<double*>(_v) = _t->spacing(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setSpacingType(*reinterpret_cast<enum SpacingType*>(_v)); break;
case 1: _t->setSpacing(*reinterpret_cast<double*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPBarsGroup::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPBarsGroup::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPBarsGroupE_t>.strings))
return static_cast<void*>(this);
return QObject::qt_metacast(_clname);
}
int QCPBarsGroup::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN7QCPBarsE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPBars::qt_create_metaobjectdata<qt_meta_tag_ZN7QCPBarsE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPBars",
"width",
"widthType",
"WidthType",
"barsGroup",
"QCPBarsGroup*",
"baseValue",
"stackingGap",
"barBelow",
"QCPBars*",
"barAbove",
"wtAbsolute",
"wtAxisRectRatio",
"wtPlotCoords"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'width'
QtMocHelpers::PropertyData<double>(1, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'widthType'
QtMocHelpers::PropertyData<enum WidthType>(2, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'barsGroup'
QtMocHelpers::PropertyData<QCPBarsGroup*>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'baseValue'
QtMocHelpers::PropertyData<double>(6, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'stackingGap'
QtMocHelpers::PropertyData<double>(7, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'barBelow'
QtMocHelpers::PropertyData<QCPBars*>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'barAbove'
QtMocHelpers::PropertyData<QCPBars*>(10, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
};
QtMocHelpers::UintData qt_enums {
// enum 'WidthType'
QtMocHelpers::EnumData<enum WidthType>(3, 3, QMC::EnumFlags{}).add({
{ 11, WidthType::wtAbsolute },
{ 12, WidthType::wtAxisRectRatio },
{ 13, WidthType::wtPlotCoords },
}),
};
return QtMocHelpers::metaObjectData<QCPBars, qt_meta_tag_ZN7QCPBarsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPBars::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable1D<QCPBarsData>::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPBarsE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPBarsE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7QCPBarsE_t>.metaTypes,
nullptr
} };
void QCPBars::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPBars *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 6:
case 5:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPBars* >(); break;
case 2:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPBarsGroup* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<double*>(_v) = _t->width(); break;
case 1: *reinterpret_cast<enum WidthType*>(_v) = _t->widthType(); break;
case 2: *reinterpret_cast<QCPBarsGroup**>(_v) = _t->barsGroup(); break;
case 3: *reinterpret_cast<double*>(_v) = _t->baseValue(); break;
case 4: *reinterpret_cast<double*>(_v) = _t->stackingGap(); break;
case 5: *reinterpret_cast<QCPBars**>(_v) = _t->barBelow(); break;
case 6: *reinterpret_cast<QCPBars**>(_v) = _t->barAbove(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setWidth(*reinterpret_cast<double*>(_v)); break;
case 1: _t->setWidthType(*reinterpret_cast<enum WidthType*>(_v)); break;
case 2: _t->setBarsGroup(*reinterpret_cast<QCPBarsGroup**>(_v)); break;
case 3: _t->setBaseValue(*reinterpret_cast<double*>(_v)); break;
case 4: _t->setStackingGap(*reinterpret_cast<double*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPBars::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPBars::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QCPBarsE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractPlottable1D<QCPBarsData>::qt_metacast(_clname);
}
int QCPBars::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable1D<QCPBarsData>::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN17QCPStatisticalBoxE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPStatisticalBox::qt_create_metaobjectdata<qt_meta_tag_ZN17QCPStatisticalBoxE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPStatisticalBox",
"width",
"whiskerWidth",
"whiskerPen",
"whiskerBarPen",
"whiskerAntialiased",
"medianPen",
"outlierStyle",
"QCPScatterStyle"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'width'
QtMocHelpers::PropertyData<double>(1, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'whiskerWidth'
QtMocHelpers::PropertyData<double>(2, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'whiskerPen'
QtMocHelpers::PropertyData<QPen>(3, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'whiskerBarPen'
QtMocHelpers::PropertyData<QPen>(4, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'whiskerAntialiased'
QtMocHelpers::PropertyData<bool>(5, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'medianPen'
QtMocHelpers::PropertyData<QPen>(6, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'outlierStyle'
QtMocHelpers::PropertyData<QCPScatterStyle>(7, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPStatisticalBox, qt_meta_tag_ZN17QCPStatisticalBoxE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPStatisticalBox::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable1D<QCPStatisticalBoxData>::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QCPStatisticalBoxE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QCPStatisticalBoxE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QCPStatisticalBoxE_t>.metaTypes,
nullptr
} };
void QCPStatisticalBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPStatisticalBox *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<double*>(_v) = _t->width(); break;
case 1: *reinterpret_cast<double*>(_v) = _t->whiskerWidth(); break;
case 2: *reinterpret_cast<QPen*>(_v) = _t->whiskerPen(); break;
case 3: *reinterpret_cast<QPen*>(_v) = _t->whiskerBarPen(); break;
case 4: *reinterpret_cast<bool*>(_v) = _t->whiskerAntialiased(); break;
case 5: *reinterpret_cast<QPen*>(_v) = _t->medianPen(); break;
case 6: *reinterpret_cast<QCPScatterStyle*>(_v) = _t->outlierStyle(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setWidth(*reinterpret_cast<double*>(_v)); break;
case 1: _t->setWhiskerWidth(*reinterpret_cast<double*>(_v)); break;
case 2: _t->setWhiskerPen(*reinterpret_cast<QPen*>(_v)); break;
case 3: _t->setWhiskerBarPen(*reinterpret_cast<QPen*>(_v)); break;
case 4: _t->setWhiskerAntialiased(*reinterpret_cast<bool*>(_v)); break;
case 5: _t->setMedianPen(*reinterpret_cast<QPen*>(_v)); break;
case 6: _t->setOutlierStyle(*reinterpret_cast<QCPScatterStyle*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPStatisticalBox::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPStatisticalBox::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QCPStatisticalBoxE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractPlottable1D<QCPStatisticalBoxData>::qt_metacast(_clname);
}
int QCPStatisticalBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable1D<QCPStatisticalBoxData>::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN11QCPColorMapE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPColorMap::qt_create_metaobjectdata<qt_meta_tag_ZN11QCPColorMapE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPColorMap",
"dataRangeChanged",
"",
"QCPRange",
"newRange",
"dataScaleTypeChanged",
"QCPAxis::ScaleType",
"scaleType",
"gradientChanged",
"QCPColorGradient",
"newGradient",
"setDataRange",
"dataRange",
"setDataScaleType",
"setGradient",
"gradient",
"updateLegendIcon",
"Qt::TransformationMode",
"transformMode",
"thumbSize",
"dataScaleType",
"interpolate",
"tightBoundary",
"colorScale",
"QCPColorScale*"
};
QtMocHelpers::UintData qt_methods {
// Signal 'dataRangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'dataScaleTypeChanged'
QtMocHelpers::SignalData<void(QCPAxis::ScaleType)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 6, 7 },
}}),
// Signal 'gradientChanged'
QtMocHelpers::SignalData<void(const QCPColorGradient &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 9, 10 },
}}),
// Slot 'setDataRange'
QtMocHelpers::SlotData<void(const QCPRange &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 12 },
}}),
// Slot 'setDataScaleType'
QtMocHelpers::SlotData<void(QCPAxis::ScaleType)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 6, 7 },
}}),
// Slot 'setGradient'
QtMocHelpers::SlotData<void(const QCPColorGradient &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 9, 15 },
}}),
// Slot 'updateLegendIcon'
QtMocHelpers::SlotData<void(Qt::TransformationMode, const QSize &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 17, 18 }, { QMetaType::QSize, 19 },
}}),
// Slot 'updateLegendIcon'
QtMocHelpers::SlotData<void(Qt::TransformationMode)>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
{ 0x80000000 | 17, 18 },
}}),
// Slot 'updateLegendIcon'
QtMocHelpers::SlotData<void()>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
// property 'dataRange'
QtMocHelpers::PropertyData<QCPRange>(12, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
// property 'dataScaleType'
QtMocHelpers::PropertyData<QCPAxis::ScaleType>(20, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
// property 'gradient'
QtMocHelpers::PropertyData<QCPColorGradient>(15, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
// property 'interpolate'
QtMocHelpers::PropertyData<bool>(21, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'tightBoundary'
QtMocHelpers::PropertyData<bool>(22, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'colorScale'
QtMocHelpers::PropertyData<QCPColorScale*>(23, 0x80000000 | 24, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPColorMap, qt_meta_tag_ZN11QCPColorMapE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN11QCPColorMapE[] = {
QMetaObject::SuperData::link<QCPAxis::staticMetaObject>(),
nullptr
};
Q_CONSTINIT const QMetaObject QCPColorMap::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPColorMapE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPColorMapE_t>.data,
qt_static_metacall,
qt_meta_extradata_ZN11QCPColorMapE,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QCPColorMapE_t>.metaTypes,
nullptr
} };
void QCPColorMap::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPColorMap *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->dataRangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 1: _t->dataScaleTypeChanged((*reinterpret_cast< std::add_pointer_t<QCPAxis::ScaleType>>(_a[1]))); break;
case 2: _t->gradientChanged((*reinterpret_cast< std::add_pointer_t<QCPColorGradient>>(_a[1]))); break;
case 3: _t->setDataRange((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 4: _t->setDataScaleType((*reinterpret_cast< std::add_pointer_t<QCPAxis::ScaleType>>(_a[1]))); break;
case 5: _t->setGradient((*reinterpret_cast< std::add_pointer_t<QCPColorGradient>>(_a[1]))); break;
case 6: _t->updateLegendIcon((*reinterpret_cast< std::add_pointer_t<Qt::TransformationMode>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QSize>>(_a[2]))); break;
case 7: _t->updateLegendIcon((*reinterpret_cast< std::add_pointer_t<Qt::TransformationMode>>(_a[1]))); break;
case 8: _t->updateLegendIcon(); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 1:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::ScaleType >(); break;
}
break;
case 4:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPAxis::ScaleType >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPColorMap::*)(const QCPRange & )>(_a, &QCPColorMap::dataRangeChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPColorMap::*)(QCPAxis::ScaleType )>(_a, &QCPColorMap::dataScaleTypeChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPColorMap::*)(const QCPColorGradient & )>(_a, &QCPColorMap::gradientChanged, 2))
return;
}
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 1:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAxis::ScaleType >(); break;
case 5:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPColorScale* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QCPRange*>(_v) = _t->dataRange(); break;
case 1: *reinterpret_cast<QCPAxis::ScaleType*>(_v) = _t->dataScaleType(); break;
case 2: *reinterpret_cast<QCPColorGradient*>(_v) = _t->gradient(); break;
case 3: *reinterpret_cast<bool*>(_v) = _t->interpolate(); break;
case 4: *reinterpret_cast<bool*>(_v) = _t->tightBoundary(); break;
case 5: *reinterpret_cast<QCPColorScale**>(_v) = _t->colorScale(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setDataRange(*reinterpret_cast<QCPRange*>(_v)); break;
case 1: _t->setDataScaleType(*reinterpret_cast<QCPAxis::ScaleType*>(_v)); break;
case 2: _t->setGradient(*reinterpret_cast<QCPColorGradient*>(_v)); break;
case 3: _t->setInterpolate(*reinterpret_cast<bool*>(_v)); break;
case 4: _t->setTightBoundary(*reinterpret_cast<bool*>(_v)); break;
case 5: _t->setColorScale(*reinterpret_cast<QCPColorScale**>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPColorMap::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPColorMap::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPColorMapE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractPlottable::qt_metacast(_clname);
}
int QCPColorMap::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
return _id;
}
// SIGNAL 0
void QCPColorMap::dataRangeChanged(const QCPRange & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPColorMap::dataScaleTypeChanged(QCPAxis::ScaleType _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void QCPColorMap::gradientChanged(const QCPColorGradient & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN12QCPFinancialE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPFinancial::qt_create_metaobjectdata<qt_meta_tag_ZN12QCPFinancialE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPFinancial",
"chartStyle",
"ChartStyle",
"width",
"widthType",
"WidthType",
"twoColored",
"brushPositive",
"brushNegative",
"penPositive",
"penNegative",
"wtAbsolute",
"wtAxisRectRatio",
"wtPlotCoords",
"csOhlc",
"csCandlestick"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'chartStyle'
QtMocHelpers::PropertyData<enum ChartStyle>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'width'
QtMocHelpers::PropertyData<double>(3, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'widthType'
QtMocHelpers::PropertyData<enum WidthType>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'twoColored'
QtMocHelpers::PropertyData<bool>(6, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brushPositive'
QtMocHelpers::PropertyData<QBrush>(7, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brushNegative'
QtMocHelpers::PropertyData<QBrush>(8, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'penPositive'
QtMocHelpers::PropertyData<QPen>(9, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'penNegative'
QtMocHelpers::PropertyData<QPen>(10, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'WidthType'
QtMocHelpers::EnumData<enum WidthType>(5, 5, QMC::EnumFlags{}).add({
{ 11, WidthType::wtAbsolute },
{ 12, WidthType::wtAxisRectRatio },
{ 13, WidthType::wtPlotCoords },
}),
// enum 'ChartStyle'
QtMocHelpers::EnumData<enum ChartStyle>(2, 2, QMC::EnumFlags{}).add({
{ 14, ChartStyle::csOhlc },
{ 15, ChartStyle::csCandlestick },
}),
};
return QtMocHelpers::metaObjectData<QCPFinancial, qt_meta_tag_ZN12QCPFinancialE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPFinancial::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable1D<QCPFinancialData>::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPFinancialE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPFinancialE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QCPFinancialE_t>.metaTypes,
nullptr
} };
void QCPFinancial::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPFinancial *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<enum ChartStyle*>(_v) = _t->chartStyle(); break;
case 1: *reinterpret_cast<double*>(_v) = _t->width(); break;
case 2: *reinterpret_cast<enum WidthType*>(_v) = _t->widthType(); break;
case 3: *reinterpret_cast<bool*>(_v) = _t->twoColored(); break;
case 4: *reinterpret_cast<QBrush*>(_v) = _t->brushPositive(); break;
case 5: *reinterpret_cast<QBrush*>(_v) = _t->brushNegative(); break;
case 6: *reinterpret_cast<QPen*>(_v) = _t->penPositive(); break;
case 7: *reinterpret_cast<QPen*>(_v) = _t->penNegative(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setChartStyle(*reinterpret_cast<enum ChartStyle*>(_v)); break;
case 1: _t->setWidth(*reinterpret_cast<double*>(_v)); break;
case 2: _t->setWidthType(*reinterpret_cast<enum WidthType*>(_v)); break;
case 3: _t->setTwoColored(*reinterpret_cast<bool*>(_v)); break;
case 4: _t->setBrushPositive(*reinterpret_cast<QBrush*>(_v)); break;
case 5: _t->setBrushNegative(*reinterpret_cast<QBrush*>(_v)); break;
case 6: _t->setPenPositive(*reinterpret_cast<QPen*>(_v)); break;
case 7: _t->setPenNegative(*reinterpret_cast<QPen*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPFinancial::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPFinancial::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPFinancialE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractPlottable1D<QCPFinancialData>::qt_metacast(_clname);
}
int QCPFinancial::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable1D<QCPFinancialData>::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN12QCPErrorBarsE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPErrorBars::qt_create_metaobjectdata<qt_meta_tag_ZN12QCPErrorBarsE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPErrorBars",
"data",
"QSharedPointer<QCPErrorBarsDataContainer>",
"dataPlottable",
"QCPAbstractPlottable*",
"errorType",
"ErrorType",
"whiskerWidth",
"symbolGap",
"etKeyError",
"etValueError"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'data'
QtMocHelpers::PropertyData<QSharedPointer<QCPErrorBarsDataContainer>>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'dataPlottable'
QtMocHelpers::PropertyData<QCPAbstractPlottable*>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'errorType'
QtMocHelpers::PropertyData<enum ErrorType>(5, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'whiskerWidth'
QtMocHelpers::PropertyData<double>(7, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'symbolGap'
QtMocHelpers::PropertyData<double>(8, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'ErrorType'
QtMocHelpers::EnumData<enum ErrorType>(6, 6, QMC::EnumFlags{}).add({
{ 9, ErrorType::etKeyError },
{ 10, ErrorType::etValueError },
}),
};
return QtMocHelpers::metaObjectData<QCPErrorBars, qt_meta_tag_ZN12QCPErrorBarsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPErrorBars::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractPlottable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPErrorBarsE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPErrorBarsE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QCPErrorBarsE_t>.metaTypes,
nullptr
} };
void QCPErrorBars::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPErrorBars *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 1:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPAbstractPlottable* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QSharedPointer<QCPErrorBarsDataContainer>*>(_v) = _t->data(); break;
case 1: *reinterpret_cast<QCPAbstractPlottable**>(_v) = _t->dataPlottable(); break;
case 2: *reinterpret_cast<enum ErrorType*>(_v) = _t->errorType(); break;
case 3: *reinterpret_cast<double*>(_v) = _t->whiskerWidth(); break;
case 4: *reinterpret_cast<double*>(_v) = _t->symbolGap(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setData(*reinterpret_cast<QSharedPointer<QCPErrorBarsDataContainer>*>(_v)); break;
case 1: _t->setDataPlottable(*reinterpret_cast<QCPAbstractPlottable**>(_v)); break;
case 2: _t->setErrorType(*reinterpret_cast<enum ErrorType*>(_v)); break;
case 3: _t->setWhiskerWidth(*reinterpret_cast<double*>(_v)); break;
case 4: _t->setSymbolGap(*reinterpret_cast<double*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPErrorBars::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPErrorBars::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPErrorBarsE_t>.strings))
return static_cast<void*>(this);
if (!strcmp(_clname, "QCPPlottableInterface1D"))
return static_cast< QCPPlottableInterface1D*>(this);
return QCPAbstractPlottable::qt_metacast(_clname);
}
int QCPErrorBars::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractPlottable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN19QCPItemStraightLineE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemStraightLine::qt_create_metaobjectdata<qt_meta_tag_ZN19QCPItemStraightLineE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemStraightLine",
"pen",
"selectedPen"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemStraightLine, qt_meta_tag_ZN19QCPItemStraightLineE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemStraightLine::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QCPItemStraightLineE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QCPItemStraightLineE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QCPItemStraightLineE_t>.metaTypes,
nullptr
} };
void QCPItemStraightLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemStraightLine *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemStraightLine::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemStraightLine::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QCPItemStraightLineE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemStraightLine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN11QCPItemLineE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemLine::qt_create_metaobjectdata<qt_meta_tag_ZN11QCPItemLineE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemLine",
"pen",
"selectedPen",
"head",
"QCPLineEnding",
"tail"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'head'
QtMocHelpers::PropertyData<QCPLineEnding>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'tail'
QtMocHelpers::PropertyData<QCPLineEnding>(5, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemLine, qt_meta_tag_ZN11QCPItemLineE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemLine::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemLineE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemLineE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QCPItemLineE_t>.metaTypes,
nullptr
} };
void QCPItemLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemLine *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 2: *reinterpret_cast<QCPLineEnding*>(_v) = _t->head(); break;
case 3: *reinterpret_cast<QCPLineEnding*>(_v) = _t->tail(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 2: _t->setHead(*reinterpret_cast<QCPLineEnding*>(_v)); break;
case 3: _t->setTail(*reinterpret_cast<QCPLineEnding*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemLine::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemLine::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemLineE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemLine::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN12QCPItemCurveE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemCurve::qt_create_metaobjectdata<qt_meta_tag_ZN12QCPItemCurveE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemCurve",
"pen",
"selectedPen",
"head",
"QCPLineEnding",
"tail"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'head'
QtMocHelpers::PropertyData<QCPLineEnding>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'tail'
QtMocHelpers::PropertyData<QCPLineEnding>(5, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemCurve, qt_meta_tag_ZN12QCPItemCurveE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemCurve::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPItemCurveE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPItemCurveE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QCPItemCurveE_t>.metaTypes,
nullptr
} };
void QCPItemCurve::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemCurve *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 2: *reinterpret_cast<QCPLineEnding*>(_v) = _t->head(); break;
case 3: *reinterpret_cast<QCPLineEnding*>(_v) = _t->tail(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 2: _t->setHead(*reinterpret_cast<QCPLineEnding*>(_v)); break;
case 3: _t->setTail(*reinterpret_cast<QCPLineEnding*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemCurve::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemCurve::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPItemCurveE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemCurve::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN11QCPItemRectE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemRect::qt_create_metaobjectdata<qt_meta_tag_ZN11QCPItemRectE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemRect",
"pen",
"selectedPen",
"brush",
"selectedBrush"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brush'
QtMocHelpers::PropertyData<QBrush>(3, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedBrush'
QtMocHelpers::PropertyData<QBrush>(4, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemRect, qt_meta_tag_ZN11QCPItemRectE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemRect::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemRectE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemRectE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QCPItemRectE_t>.metaTypes,
nullptr
} };
void QCPItemRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemRect *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 2: *reinterpret_cast<QBrush*>(_v) = _t->brush(); break;
case 3: *reinterpret_cast<QBrush*>(_v) = _t->selectedBrush(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 2: _t->setBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 3: _t->setSelectedBrush(*reinterpret_cast<QBrush*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemRect::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemRect::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemRectE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemRect::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN11QCPItemTextE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemText::qt_create_metaobjectdata<qt_meta_tag_ZN11QCPItemTextE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemText",
"color",
"selectedColor",
"pen",
"selectedPen",
"brush",
"selectedBrush",
"font",
"selectedFont",
"text",
"positionAlignment",
"Qt::Alignment",
"textAlignment",
"rotation",
"padding",
"QMargins"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'color'
QtMocHelpers::PropertyData<QColor>(1, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedColor'
QtMocHelpers::PropertyData<QColor>(2, QMetaType::QColor, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'pen'
QtMocHelpers::PropertyData<QPen>(3, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(4, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brush'
QtMocHelpers::PropertyData<QBrush>(5, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedBrush'
QtMocHelpers::PropertyData<QBrush>(6, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'font'
QtMocHelpers::PropertyData<QFont>(7, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedFont'
QtMocHelpers::PropertyData<QFont>(8, QMetaType::QFont, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'text'
QtMocHelpers::PropertyData<QString>(9, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'positionAlignment'
QtMocHelpers::PropertyData<Qt::Alignment>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'textAlignment'
QtMocHelpers::PropertyData<Qt::Alignment>(12, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'rotation'
QtMocHelpers::PropertyData<double>(13, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'padding'
QtMocHelpers::PropertyData<QMargins>(14, 0x80000000 | 15, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemText, qt_meta_tag_ZN11QCPItemTextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemText::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemTextE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemTextE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QCPItemTextE_t>.metaTypes,
nullptr
} };
void QCPItemText::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemText *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QColor*>(_v) = _t->color(); break;
case 1: *reinterpret_cast<QColor*>(_v) = _t->selectedColor(); break;
case 2: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 3: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 4: *reinterpret_cast<QBrush*>(_v) = _t->brush(); break;
case 5: *reinterpret_cast<QBrush*>(_v) = _t->selectedBrush(); break;
case 6: *reinterpret_cast<QFont*>(_v) = _t->font(); break;
case 7: *reinterpret_cast<QFont*>(_v) = _t->selectedFont(); break;
case 8: *reinterpret_cast<QString*>(_v) = _t->text(); break;
case 9: *reinterpret_cast<Qt::Alignment*>(_v) = _t->positionAlignment(); break;
case 10: *reinterpret_cast<Qt::Alignment*>(_v) = _t->textAlignment(); break;
case 11: *reinterpret_cast<double*>(_v) = _t->rotation(); break;
case 12: *reinterpret_cast<QMargins*>(_v) = _t->padding(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setColor(*reinterpret_cast<QColor*>(_v)); break;
case 1: _t->setSelectedColor(*reinterpret_cast<QColor*>(_v)); break;
case 2: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 3: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 4: _t->setBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 5: _t->setSelectedBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 6: _t->setFont(*reinterpret_cast<QFont*>(_v)); break;
case 7: _t->setSelectedFont(*reinterpret_cast<QFont*>(_v)); break;
case 8: _t->setText(*reinterpret_cast<QString*>(_v)); break;
case 9: _t->setPositionAlignment(*reinterpret_cast<Qt::Alignment*>(_v)); break;
case 10: _t->setTextAlignment(*reinterpret_cast<Qt::Alignment*>(_v)); break;
case 11: _t->setRotation(*reinterpret_cast<double*>(_v)); break;
case 12: _t->setPadding(*reinterpret_cast<QMargins*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemText::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemText::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QCPItemTextE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemText::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 13;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN14QCPItemEllipseE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemEllipse::qt_create_metaobjectdata<qt_meta_tag_ZN14QCPItemEllipseE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemEllipse",
"pen",
"selectedPen",
"brush",
"selectedBrush"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brush'
QtMocHelpers::PropertyData<QBrush>(3, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedBrush'
QtMocHelpers::PropertyData<QBrush>(4, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemEllipse, qt_meta_tag_ZN14QCPItemEllipseE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemEllipse::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPItemEllipseE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPItemEllipseE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QCPItemEllipseE_t>.metaTypes,
nullptr
} };
void QCPItemEllipse::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemEllipse *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 2: *reinterpret_cast<QBrush*>(_v) = _t->brush(); break;
case 3: *reinterpret_cast<QBrush*>(_v) = _t->selectedBrush(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 2: _t->setBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 3: _t->setSelectedBrush(*reinterpret_cast<QBrush*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemEllipse::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemEllipse::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPItemEllipseE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemEllipse::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN13QCPItemPixmapE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemPixmap::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPItemPixmapE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemPixmap",
"pixmap",
"scaled",
"aspectRatioMode",
"Qt::AspectRatioMode",
"transformationMode",
"Qt::TransformationMode",
"pen",
"selectedPen"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pixmap'
QtMocHelpers::PropertyData<QPixmap>(1, QMetaType::QPixmap, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'scaled'
QtMocHelpers::PropertyData<bool>(2, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'aspectRatioMode'
QtMocHelpers::PropertyData<Qt::AspectRatioMode>(3, 0x80000000 | 4, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'transformationMode'
QtMocHelpers::PropertyData<Qt::TransformationMode>(5, 0x80000000 | 6, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
// property 'pen'
QtMocHelpers::PropertyData<QPen>(7, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(8, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPItemPixmap, qt_meta_tag_ZN13QCPItemPixmapE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemPixmap::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemPixmapE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemPixmapE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPItemPixmapE_t>.metaTypes,
nullptr
} };
void QCPItemPixmap::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemPixmap *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPixmap*>(_v) = _t->pixmap(); break;
case 1: *reinterpret_cast<bool*>(_v) = _t->scaled(); break;
case 2: *reinterpret_cast<Qt::AspectRatioMode*>(_v) = _t->aspectRatioMode(); break;
case 3: *reinterpret_cast<Qt::TransformationMode*>(_v) = _t->transformationMode(); break;
case 4: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 5: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPixmap(*reinterpret_cast<QPixmap*>(_v)); break;
case 1: _t->setScaled(*reinterpret_cast<bool*>(_v)); break;
case 4: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 5: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemPixmap::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemPixmap::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemPixmapE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemPixmap::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 6;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN13QCPItemTracerE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemTracer::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPItemTracerE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemTracer",
"pen",
"selectedPen",
"brush",
"selectedBrush",
"size",
"style",
"TracerStyle",
"graph",
"QCPGraph*",
"graphKey",
"interpolating",
"tsNone",
"tsPlus",
"tsCrosshair",
"tsCircle",
"tsSquare"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'brush'
QtMocHelpers::PropertyData<QBrush>(3, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedBrush'
QtMocHelpers::PropertyData<QBrush>(4, QMetaType::QBrush, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'size'
QtMocHelpers::PropertyData<double>(5, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'style'
QtMocHelpers::PropertyData<enum TracerStyle>(6, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'graph'
QtMocHelpers::PropertyData<QCPGraph*>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
// property 'graphKey'
QtMocHelpers::PropertyData<double>(10, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'interpolating'
QtMocHelpers::PropertyData<bool>(11, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'TracerStyle'
QtMocHelpers::EnumData<enum TracerStyle>(7, 7, QMC::EnumFlags{}).add({
{ 12, TracerStyle::tsNone },
{ 13, TracerStyle::tsPlus },
{ 14, TracerStyle::tsCrosshair },
{ 15, TracerStyle::tsCircle },
{ 16, TracerStyle::tsSquare },
}),
};
return QtMocHelpers::metaObjectData<QCPItemTracer, qt_meta_tag_ZN13QCPItemTracerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemTracer::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemTracerE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemTracerE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPItemTracerE_t>.metaTypes,
nullptr
} };
void QCPItemTracer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemTracer *>(_o);
if (_c == QMetaObject::RegisterPropertyMetaType) {
switch (_id) {
default: *reinterpret_cast<int*>(_a[0]) = -1; break;
case 6:
*reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QCPGraph* >(); break;
}
}
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 2: *reinterpret_cast<QBrush*>(_v) = _t->brush(); break;
case 3: *reinterpret_cast<QBrush*>(_v) = _t->selectedBrush(); break;
case 4: *reinterpret_cast<double*>(_v) = _t->size(); break;
case 5: *reinterpret_cast<enum TracerStyle*>(_v) = _t->style(); break;
case 6: *reinterpret_cast<QCPGraph**>(_v) = _t->graph(); break;
case 7: *reinterpret_cast<double*>(_v) = _t->graphKey(); break;
case 8: *reinterpret_cast<bool*>(_v) = _t->interpolating(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 2: _t->setBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 3: _t->setSelectedBrush(*reinterpret_cast<QBrush*>(_v)); break;
case 4: _t->setSize(*reinterpret_cast<double*>(_v)); break;
case 5: _t->setStyle(*reinterpret_cast<enum TracerStyle*>(_v)); break;
case 6: _t->setGraph(*reinterpret_cast<QCPGraph**>(_v)); break;
case 7: _t->setGraphKey(*reinterpret_cast<double*>(_v)); break;
case 8: _t->setInterpolating(*reinterpret_cast<bool*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemTracer::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemTracer::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPItemTracerE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemTracer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN14QCPItemBracketE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPItemBracket::qt_create_metaobjectdata<qt_meta_tag_ZN14QCPItemBracketE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPItemBracket",
"pen",
"selectedPen",
"length",
"style",
"BracketStyle",
"bsSquare",
"bsRound",
"bsCurly",
"bsCalligraphic"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
// property 'pen'
QtMocHelpers::PropertyData<QPen>(1, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'selectedPen'
QtMocHelpers::PropertyData<QPen>(2, QMetaType::QPen, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'length'
QtMocHelpers::PropertyData<double>(3, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
// property 'style'
QtMocHelpers::PropertyData<enum BracketStyle>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
};
QtMocHelpers::UintData qt_enums {
// enum 'BracketStyle'
QtMocHelpers::EnumData<enum BracketStyle>(5, 5, QMC::EnumFlags{}).add({
{ 6, BracketStyle::bsSquare },
{ 7, BracketStyle::bsRound },
{ 8, BracketStyle::bsCurly },
{ 9, BracketStyle::bsCalligraphic },
}),
};
return QtMocHelpers::metaObjectData<QCPItemBracket, qt_meta_tag_ZN14QCPItemBracketE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPItemBracket::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPItemBracketE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPItemBracketE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14QCPItemBracketE_t>.metaTypes,
nullptr
} };
void QCPItemBracket::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPItemBracket *>(_o);
if (_c == QMetaObject::ReadProperty) {
void *_v = _a[0];
switch (_id) {
case 0: *reinterpret_cast<QPen*>(_v) = _t->pen(); break;
case 1: *reinterpret_cast<QPen*>(_v) = _t->selectedPen(); break;
case 2: *reinterpret_cast<double*>(_v) = _t->length(); break;
case 3: *reinterpret_cast<enum BracketStyle*>(_v) = _t->style(); break;
default: break;
}
}
if (_c == QMetaObject::WriteProperty) {
void *_v = _a[0];
switch (_id) {
case 0: _t->setPen(*reinterpret_cast<QPen*>(_v)); break;
case 1: _t->setSelectedPen(*reinterpret_cast<QPen*>(_v)); break;
case 2: _t->setLength(*reinterpret_cast<double*>(_v)); break;
case 3: _t->setStyle(*reinterpret_cast<enum BracketStyle*>(_v)); break;
default: break;
}
}
}
const QMetaObject *QCPItemBracket::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPItemBracket::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14QCPItemBracketE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractItem::qt_metacast(_clname);
}
int QCPItemBracket::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractItem::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
|| _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
|| _c == QMetaObject::RegisterPropertyMetaType) {
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
return _id;
}
namespace {
struct qt_meta_tag_ZN18QCPPolarAxisRadialE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPolarAxisRadial::qt_create_metaobjectdata<qt_meta_tag_ZN18QCPPolarAxisRadialE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPolarAxisRadial",
"rangeChanged",
"",
"QCPRange",
"newRange",
"oldRange",
"scaleTypeChanged",
"QCPPolarAxisRadial::ScaleType",
"scaleType",
"selectionChanged",
"QCPPolarAxisRadial::SelectableParts",
"parts",
"selectableChanged",
"setScaleType",
"type",
"setRange",
"range",
"setSelectableParts",
"selectableParts",
"setSelectedParts",
"selectedParts",
"AngleReference",
"arAbsolute",
"arAngularAxis",
"ScaleType",
"stLinear",
"stLogarithmic",
"SelectablePart",
"spNone",
"spAxis",
"spTickLabels",
"spAxisLabel",
"SelectableParts",
"LabelMode",
"lmUpright",
"lmRotated"
};
QtMocHelpers::UintData qt_methods {
// Signal 'rangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'rangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &, const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 }, { 0x80000000 | 3, 5 },
}}),
// Signal 'scaleTypeChanged'
QtMocHelpers::SignalData<void(QCPPolarAxisRadial::ScaleType)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(const QCPPolarAxisRadial::SelectableParts &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 11 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(const QCPPolarAxisRadial::SelectableParts &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 11 },
}}),
// Slot 'setScaleType'
QtMocHelpers::SlotData<void(QCPPolarAxisRadial::ScaleType)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 14 },
}}),
// Slot 'setRange'
QtMocHelpers::SlotData<void(const QCPRange &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 16 },
}}),
// Slot 'setSelectableParts'
QtMocHelpers::SlotData<void(const QCPPolarAxisRadial::SelectableParts &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 18 },
}}),
// Slot 'setSelectedParts'
QtMocHelpers::SlotData<void(const QCPPolarAxisRadial::SelectableParts &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 10, 20 },
}}),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'AngleReference'
QtMocHelpers::EnumData<enum AngleReference>(21, 21, QMC::EnumFlags{}).add({
{ 22, AngleReference::arAbsolute },
{ 23, AngleReference::arAngularAxis },
}),
// enum 'ScaleType'
QtMocHelpers::EnumData<enum ScaleType>(24, 24, QMC::EnumFlags{}).add({
{ 25, ScaleType::stLinear },
{ 26, ScaleType::stLogarithmic },
}),
// enum 'SelectablePart'
QtMocHelpers::EnumData<enum SelectablePart>(27, 27, QMC::EnumFlags{}).add({
{ 28, SelectablePart::spNone },
{ 29, SelectablePart::spAxis },
{ 30, SelectablePart::spTickLabels },
{ 31, SelectablePart::spAxisLabel },
}),
// enum 'SelectableParts'
QtMocHelpers::EnumData<SelectableParts>(32, 27, QMC::EnumFlags{}).add({
{ 28, SelectablePart::spNone },
{ 29, SelectablePart::spAxis },
{ 30, SelectablePart::spTickLabels },
{ 31, SelectablePart::spAxisLabel },
}),
// enum 'LabelMode'
QtMocHelpers::EnumData<enum LabelMode>(33, 33, QMC::EnumFlags{}).add({
{ 34, LabelMode::lmUpright },
{ 35, LabelMode::lmRotated },
}),
};
return QtMocHelpers::metaObjectData<QCPPolarAxisRadial, qt_meta_tag_ZN18QCPPolarAxisRadialE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPolarAxisRadial::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPPolarAxisRadialE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPPolarAxisRadialE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QCPPolarAxisRadialE_t>.metaTypes,
nullptr
} };
void QCPPolarAxisRadial::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPPolarAxisRadial *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->rangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[2]))); break;
case 2: _t->scaleTypeChanged((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisRadial::ScaleType>>(_a[1]))); break;
case 3: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisRadial::SelectableParts>>(_a[1]))); break;
case 4: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisRadial::SelectableParts>>(_a[1]))); break;
case 5: _t->setScaleType((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisRadial::ScaleType>>(_a[1]))); break;
case 6: _t->setRange((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 7: _t->setSelectableParts((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisRadial::SelectableParts>>(_a[1]))); break;
case 8: _t->setSelectedParts((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisRadial::SelectableParts>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 2:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPPolarAxisRadial::ScaleType >(); break;
}
break;
case 5:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPPolarAxisRadial::ScaleType >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisRadial::*)(const QCPRange & )>(_a, &QCPPolarAxisRadial::rangeChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisRadial::*)(const QCPRange & , const QCPRange & )>(_a, &QCPPolarAxisRadial::rangeChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisRadial::*)(QCPPolarAxisRadial::ScaleType )>(_a, &QCPPolarAxisRadial::scaleTypeChanged, 2))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisRadial::*)(const QCPPolarAxisRadial::SelectableParts & )>(_a, &QCPPolarAxisRadial::selectionChanged, 3))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisRadial::*)(const QCPPolarAxisRadial::SelectableParts & )>(_a, &QCPPolarAxisRadial::selectableChanged, 4))
return;
}
}
const QMetaObject *QCPPolarAxisRadial::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPPolarAxisRadial::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPPolarAxisRadialE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPPolarAxisRadial::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
return _id;
}
// SIGNAL 0
void QCPPolarAxisRadial::rangeChanged(const QCPRange & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPPolarAxisRadial::rangeChanged(const QCPRange & _t1, const QCPRange & _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}
// SIGNAL 2
void QCPPolarAxisRadial::scaleTypeChanged(QCPPolarAxisRadial::ScaleType _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
// SIGNAL 3
void QCPPolarAxisRadial::selectionChanged(const QCPPolarAxisRadial::SelectableParts & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
// SIGNAL 4
void QCPPolarAxisRadial::selectableChanged(const QCPPolarAxisRadial::SelectableParts & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN19QCPPolarAxisAngularE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPolarAxisAngular::qt_create_metaobjectdata<qt_meta_tag_ZN19QCPPolarAxisAngularE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPolarAxisAngular",
"rangeChanged",
"",
"QCPRange",
"newRange",
"oldRange",
"selectionChanged",
"QCPPolarAxisAngular::SelectableParts",
"parts",
"selectableChanged",
"setRange",
"range",
"setSelectableParts",
"selectableParts",
"setSelectedParts",
"selectedParts",
"SelectablePart",
"spNone",
"spAxis",
"spTickLabels",
"spAxisLabel",
"SelectableParts",
"LabelMode",
"lmUpright",
"lmRotated"
};
QtMocHelpers::UintData qt_methods {
// Signal 'rangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 },
}}),
// Signal 'rangeChanged'
QtMocHelpers::SignalData<void(const QCPRange &, const QCPRange &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 4 }, { 0x80000000 | 3, 5 },
}}),
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(const QCPPolarAxisAngular::SelectableParts &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(const QCPPolarAxisAngular::SelectableParts &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setRange'
QtMocHelpers::SlotData<void(const QCPRange &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 3, 11 },
}}),
// Slot 'setSelectableParts'
QtMocHelpers::SlotData<void(const QCPPolarAxisAngular::SelectableParts &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 13 },
}}),
// Slot 'setSelectedParts'
QtMocHelpers::SlotData<void(const QCPPolarAxisAngular::SelectableParts &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 15 },
}}),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'SelectablePart'
QtMocHelpers::EnumData<enum SelectablePart>(16, 16, QMC::EnumFlags{}).add({
{ 17, SelectablePart::spNone },
{ 18, SelectablePart::spAxis },
{ 19, SelectablePart::spTickLabels },
{ 20, SelectablePart::spAxisLabel },
}),
// enum 'SelectableParts'
QtMocHelpers::EnumData<SelectableParts>(21, 16, QMC::EnumFlags{}).add({
{ 17, SelectablePart::spNone },
{ 18, SelectablePart::spAxis },
{ 19, SelectablePart::spTickLabels },
{ 20, SelectablePart::spAxisLabel },
}),
// enum 'LabelMode'
QtMocHelpers::EnumData<enum LabelMode>(22, 22, QMC::EnumFlags{}).add({
{ 23, LabelMode::lmUpright },
{ 24, LabelMode::lmRotated },
}),
};
return QtMocHelpers::metaObjectData<QCPPolarAxisAngular, qt_meta_tag_ZN19QCPPolarAxisAngularE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPolarAxisAngular::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayoutElement::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QCPPolarAxisAngularE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QCPPolarAxisAngularE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19QCPPolarAxisAngularE_t>.metaTypes,
nullptr
} };
void QCPPolarAxisAngular::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPPolarAxisAngular *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->rangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 1: _t->rangeChanged((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1])),(*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[2]))); break;
case 2: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisAngular::SelectableParts>>(_a[1]))); break;
case 3: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisAngular::SelectableParts>>(_a[1]))); break;
case 4: _t->setRange((*reinterpret_cast< std::add_pointer_t<QCPRange>>(_a[1]))); break;
case 5: _t->setSelectableParts((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisAngular::SelectableParts>>(_a[1]))); break;
case 6: _t->setSelectedParts((*reinterpret_cast< std::add_pointer_t<QCPPolarAxisAngular::SelectableParts>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisAngular::*)(const QCPRange & )>(_a, &QCPPolarAxisAngular::rangeChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisAngular::*)(const QCPRange & , const QCPRange & )>(_a, &QCPPolarAxisAngular::rangeChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisAngular::*)(const QCPPolarAxisAngular::SelectableParts & )>(_a, &QCPPolarAxisAngular::selectionChanged, 2))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarAxisAngular::*)(const QCPPolarAxisAngular::SelectableParts & )>(_a, &QCPPolarAxisAngular::selectableChanged, 3))
return;
}
}
const QMetaObject *QCPPolarAxisAngular::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPPolarAxisAngular::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19QCPPolarAxisAngularE_t>.strings))
return static_cast<void*>(this);
return QCPLayoutElement::qt_metacast(_clname);
}
int QCPPolarAxisAngular::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayoutElement::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 7)
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 7)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 7;
}
return _id;
}
// SIGNAL 0
void QCPPolarAxisAngular::rangeChanged(const QCPRange & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPPolarAxisAngular::rangeChanged(const QCPRange & _t1, const QCPRange & _t2)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}
// SIGNAL 2
void QCPPolarAxisAngular::selectionChanged(const QCPPolarAxisAngular::SelectableParts & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
// SIGNAL 3
void QCPPolarAxisAngular::selectableChanged(const QCPPolarAxisAngular::SelectableParts & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN12QCPPolarGridE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPolarGrid::qt_create_metaobjectdata<qt_meta_tag_ZN12QCPPolarGridE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPolarGrid",
"GridType",
"gtAngular",
"gtRadial",
"gtAll",
"gtNone",
"GridTypes"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'GridType'
QtMocHelpers::EnumData<enum GridType>(1, 1, QMC::EnumFlags{}).add({
{ 2, GridType::gtAngular },
{ 3, GridType::gtRadial },
{ 4, GridType::gtAll },
{ 5, GridType::gtNone },
}),
// enum 'GridTypes'
QtMocHelpers::EnumData<GridTypes>(6, 1, QMC::EnumFlags{}).add({
{ 2, GridType::gtAngular },
{ 3, GridType::gtRadial },
{ 4, GridType::gtAll },
{ 5, GridType::gtNone },
}),
};
return QtMocHelpers::metaObjectData<QCPPolarGrid, qt_meta_tag_ZN12QCPPolarGridE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPolarGrid::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPPolarGridE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPPolarGridE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QCPPolarGridE_t>.metaTypes,
nullptr
} };
void QCPPolarGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPPolarGrid *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *QCPPolarGrid::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPPolarGrid::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QCPPolarGridE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPPolarGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN18QCPPolarLegendItemE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPolarLegendItem::qt_create_metaobjectdata<qt_meta_tag_ZN18QCPPolarLegendItemE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPolarLegendItem"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<QCPPolarLegendItem, qt_meta_tag_ZN18QCPPolarLegendItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPolarLegendItem::staticMetaObject = { {
QMetaObject::SuperData::link<QCPAbstractLegendItem::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPPolarLegendItemE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPPolarLegendItemE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QCPPolarLegendItemE_t>.metaTypes,
nullptr
} };
void QCPPolarLegendItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPPolarLegendItem *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *QCPPolarLegendItem::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPPolarLegendItem::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QCPPolarLegendItemE_t>.strings))
return static_cast<void*>(this);
return QCPAbstractLegendItem::qt_metacast(_clname);
}
int QCPPolarLegendItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPAbstractLegendItem::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN13QCPPolarGraphE_t {};
} // unnamed namespace
template <> constexpr inline auto QCPPolarGraph::qt_create_metaobjectdata<qt_meta_tag_ZN13QCPPolarGraphE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCPPolarGraph",
"selectionChanged",
"",
"selected",
"QCPDataSelection",
"selection",
"selectableChanged",
"QCP::SelectionType",
"selectable",
"setSelectable",
"setSelection",
"LineStyle",
"lsNone",
"lsLine"
};
QtMocHelpers::UintData qt_methods {
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'selectionChanged'
QtMocHelpers::SignalData<void(const QCPDataSelection &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 4, 5 },
}}),
// Signal 'selectableChanged'
QtMocHelpers::SignalData<void(QCP::SelectionType)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setSelectable'
QtMocHelpers::SlotData<void(QCP::SelectionType)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 7, 8 },
}}),
// Slot 'setSelection'
QtMocHelpers::SlotData<void(QCPDataSelection)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 4, 5 },
}}),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'LineStyle'
QtMocHelpers::EnumData<enum LineStyle>(11, 11, QMC::EnumFlags{}).add({
{ 12, LineStyle::lsNone },
{ 13, LineStyle::lsLine },
}),
};
return QtMocHelpers::metaObjectData<QCPPolarGraph, qt_meta_tag_ZN13QCPPolarGraphE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCPPolarGraph::staticMetaObject = { {
QMetaObject::SuperData::link<QCPLayerable::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPPolarGraphE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPPolarGraphE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13QCPPolarGraphE_t>.metaTypes,
nullptr
} };
void QCPPolarGraph::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<QCPPolarGraph *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->selectionChanged((*reinterpret_cast< std::add_pointer_t<QCPDataSelection>>(_a[1]))); break;
case 2: _t->selectableChanged((*reinterpret_cast< std::add_pointer_t<QCP::SelectionType>>(_a[1]))); break;
case 3: _t->setSelectable((*reinterpret_cast< std::add_pointer_t<QCP::SelectionType>>(_a[1]))); break;
case 4: _t->setSelection((*reinterpret_cast< std::add_pointer_t<QCPDataSelection>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
switch (_id) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 1:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPDataSelection >(); break;
}
break;
case 4:
switch (*reinterpret_cast<int*>(_a[1])) {
default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
case 0:
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QCPDataSelection >(); break;
}
break;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (QCPPolarGraph::*)(bool )>(_a, &QCPPolarGraph::selectionChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarGraph::*)(const QCPDataSelection & )>(_a, &QCPPolarGraph::selectionChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (QCPPolarGraph::*)(QCP::SelectionType )>(_a, &QCPPolarGraph::selectableChanged, 2))
return;
}
}
const QMetaObject *QCPPolarGraph::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *QCPPolarGraph::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13QCPPolarGraphE_t>.strings))
return static_cast<void*>(this);
return QCPLayerable::qt_metacast(_clname);
}
int QCPPolarGraph::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QCPLayerable::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
}
return _id;
}
// SIGNAL 0
void QCPPolarGraph::selectionChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void QCPPolarGraph::selectionChanged(const QCPDataSelection & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void QCPPolarGraph::selectableChanged(QCP::SelectionType _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3QCPE_t {};
} // unnamed namespace
template <> constexpr inline auto QCP::qt_create_metaobjectdata<qt_meta_tag_ZN3QCPE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"QCP",
"ResolutionUnit",
"ruDotsPerMeter",
"ruDotsPerCentimeter",
"ruDotsPerInch",
"ExportPen",
"epNoCosmetic",
"epAllowCosmetic",
"SignDomain",
"sdNegative",
"sdBoth",
"sdPositive",
"MarginSide",
"msLeft",
"msRight",
"msTop",
"msBottom",
"msAll",
"msNone",
"MarginSides",
"AntialiasedElement",
"aeAxes",
"aeGrid",
"aeSubGrid",
"aeLegend",
"aeLegendItems",
"aePlottables",
"aeItems",
"aeScatters",
"aeFills",
"aeZeroLine",
"aeOther",
"aeAll",
"aeNone",
"AntialiasedElements",
"PlottingHint",
"phNone",
"phFastPolylines",
"phImmediateRefresh",
"phCacheLabels",
"PlottingHints",
"Interaction",
"iNone",
"iRangeDrag",
"iRangeZoom",
"iMultiSelect",
"iSelectPlottables",
"iSelectAxes",
"iSelectLegend",
"iSelectItems",
"iSelectOther",
"iSelectPlottablesBeyondAxisRect",
"Interactions",
"SelectionRectMode",
"srmNone",
"srmZoom",
"srmSelect",
"srmCustom",
"SelectionType",
"stNone",
"stWhole",
"stSingleData",
"stDataRange",
"stMultipleDataRanges"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
// enum 'ResolutionUnit'
QtMocHelpers::EnumData<ResolutionUnit>(1, 1, QMC::EnumFlags{}).add({
{ 2, ResolutionUnit::ruDotsPerMeter },
{ 3, ResolutionUnit::ruDotsPerCentimeter },
{ 4, ResolutionUnit::ruDotsPerInch },
}),
// enum 'ExportPen'
QtMocHelpers::EnumData<ExportPen>(5, 5, QMC::EnumFlags{}).add({
{ 6, ExportPen::epNoCosmetic },
{ 7, ExportPen::epAllowCosmetic },
}),
// enum 'SignDomain'
QtMocHelpers::EnumData<SignDomain>(8, 8, QMC::EnumFlags{}).add({
{ 9, SignDomain::sdNegative },
{ 10, SignDomain::sdBoth },
{ 11, SignDomain::sdPositive },
}),
// enum 'MarginSide'
QtMocHelpers::EnumData<MarginSide>(12, 12, QMC::EnumFlags{}).add({
{ 13, MarginSide::msLeft },
{ 14, MarginSide::msRight },
{ 15, MarginSide::msTop },
{ 16, MarginSide::msBottom },
{ 17, MarginSide::msAll },
{ 18, MarginSide::msNone },
}),
// enum 'MarginSides'
QtMocHelpers::EnumData<MarginSides>(19, 12, QMC::EnumFlags{}).add({
{ 13, MarginSide::msLeft },
{ 14, MarginSide::msRight },
{ 15, MarginSide::msTop },
{ 16, MarginSide::msBottom },
{ 17, MarginSide::msAll },
{ 18, MarginSide::msNone },
}),
// enum 'AntialiasedElement'
QtMocHelpers::EnumData<AntialiasedElement>(20, 20, QMC::EnumFlags{}).add({
{ 21, AntialiasedElement::aeAxes },
{ 22, AntialiasedElement::aeGrid },
{ 23, AntialiasedElement::aeSubGrid },
{ 24, AntialiasedElement::aeLegend },
{ 25, AntialiasedElement::aeLegendItems },
{ 26, AntialiasedElement::aePlottables },
{ 27, AntialiasedElement::aeItems },
{ 28, AntialiasedElement::aeScatters },
{ 29, AntialiasedElement::aeFills },
{ 30, AntialiasedElement::aeZeroLine },
{ 31, AntialiasedElement::aeOther },
{ 32, AntialiasedElement::aeAll },
{ 33, AntialiasedElement::aeNone },
}),
// enum 'AntialiasedElements'
QtMocHelpers::EnumData<AntialiasedElements>(34, 20, QMC::EnumFlags{}).add({
{ 21, AntialiasedElement::aeAxes },
{ 22, AntialiasedElement::aeGrid },
{ 23, AntialiasedElement::aeSubGrid },
{ 24, AntialiasedElement::aeLegend },
{ 25, AntialiasedElement::aeLegendItems },
{ 26, AntialiasedElement::aePlottables },
{ 27, AntialiasedElement::aeItems },
{ 28, AntialiasedElement::aeScatters },
{ 29, AntialiasedElement::aeFills },
{ 30, AntialiasedElement::aeZeroLine },
{ 31, AntialiasedElement::aeOther },
{ 32, AntialiasedElement::aeAll },
{ 33, AntialiasedElement::aeNone },
}),
// enum 'PlottingHint'
QtMocHelpers::EnumData<PlottingHint>(35, 35, QMC::EnumFlags{}).add({
{ 36, PlottingHint::phNone },
{ 37, PlottingHint::phFastPolylines },
{ 38, PlottingHint::phImmediateRefresh },
{ 39, PlottingHint::phCacheLabels },
}),
// enum 'PlottingHints'
QtMocHelpers::EnumData<PlottingHints>(40, 35, QMC::EnumFlags{}).add({
{ 36, PlottingHint::phNone },
{ 37, PlottingHint::phFastPolylines },
{ 38, PlottingHint::phImmediateRefresh },
{ 39, PlottingHint::phCacheLabels },
}),
// enum 'Interaction'
QtMocHelpers::EnumData<Interaction>(41, 41, QMC::EnumFlags{}).add({
{ 42, Interaction::iNone },
{ 43, Interaction::iRangeDrag },
{ 44, Interaction::iRangeZoom },
{ 45, Interaction::iMultiSelect },
{ 46, Interaction::iSelectPlottables },
{ 47, Interaction::iSelectAxes },
{ 48, Interaction::iSelectLegend },
{ 49, Interaction::iSelectItems },
{ 50, Interaction::iSelectOther },
{ 51, Interaction::iSelectPlottablesBeyondAxisRect },
}),
// enum 'Interactions'
QtMocHelpers::EnumData<Interactions>(52, 41, QMC::EnumFlags{}).add({
{ 42, Interaction::iNone },
{ 43, Interaction::iRangeDrag },
{ 44, Interaction::iRangeZoom },
{ 45, Interaction::iMultiSelect },
{ 46, Interaction::iSelectPlottables },
{ 47, Interaction::iSelectAxes },
{ 48, Interaction::iSelectLegend },
{ 49, Interaction::iSelectItems },
{ 50, Interaction::iSelectOther },
{ 51, Interaction::iSelectPlottablesBeyondAxisRect },
}),
// enum 'SelectionRectMode'
QtMocHelpers::EnumData<SelectionRectMode>(53, 53, QMC::EnumFlags{}).add({
{ 54, SelectionRectMode::srmNone },
{ 55, SelectionRectMode::srmZoom },
{ 56, SelectionRectMode::srmSelect },
{ 57, SelectionRectMode::srmCustom },
}),
// enum 'SelectionType'
QtMocHelpers::EnumData<SelectionType>(58, 58, QMC::EnumFlags{}).add({
{ 59, SelectionType::stNone },
{ 60, SelectionType::stWhole },
{ 61, SelectionType::stSingleData },
{ 62, SelectionType::stDataRange },
{ 63, SelectionType::stMultipleDataRanges },
}),
};
return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN3QCPE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
static constexpr auto qt_staticMetaObjectContent_ZN3QCPE =
QCP::qt_create_metaobjectdata<qt_meta_tag_ZN3QCPE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN3QCPE =
qt_staticMetaObjectContent_ZN3QCPE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN3QCPE =
qt_staticMetaObjectContent_ZN3QCPE.relocatingData;
Q_CONSTINIT const QMetaObject QCP::staticMetaObject = { {
nullptr,
qt_staticMetaObjectStaticContent_ZN3QCPE.stringdata,
qt_staticMetaObjectStaticContent_ZN3QCPE.data,
nullptr,
nullptr,
qt_staticMetaObjectRelocatingContent_ZN3QCPE.metaTypes,
nullptr
} };
QT_WARNING_POP
Reference in New Issue View Git Blame Copy Permalink