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

#include <memory>
#include "../../../../../opentoonz/toonz/sources/include/toonzqt/paramfield.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'paramfield.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.19. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_ParamField_t {
    QByteArrayData data[5];
    char stringdata0[66];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ParamField_t qt_meta_stringdata_ParamField = {
    {
QT_MOC_LITERAL(0, 0, 10), // "ParamField"
QT_MOC_LITERAL(1, 11, 19), // "currentParamChanged"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 18), // "actualParamChanged"
QT_MOC_LITERAL(4, 51, 14) // "paramKeyToggle"

    },
    "ParamField\0currentParamChanged\0\0"
    "actualParamChanged\0paramKeyToggle"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       3,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,   29,    2, 0x06 /* Public */,
       3,    0,   30,    2, 0x06 /* Public */,
       4,    0,   31,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void ParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->currentParamChanged(); break;
        case 1: _t->actualParamChanged(); break;
        case 2: _t->paramKeyToggle(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ParamField::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParamField::currentParamChanged)) {
                *result = 0;
                return;
            }
        }
        {
            using _t = void (ParamField::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParamField::actualParamChanged)) {
                *result = 1;
                return;
            }
        }
        {
            using _t = void (ParamField::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParamField::paramKeyToggle)) {
                *result = 2;
                return;
            }
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject ParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_meta_stringdata_ParamField.data,
    qt_meta_data_ParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *ParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ParamField.stringdata0))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

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

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

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

// SIGNAL 2
void ParamField::paramKeyToggle()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
struct qt_meta_stringdata_ParamFieldKeyToggle_t {
    QByteArrayData data[13];
    char stringdata0[214];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ParamFieldKeyToggle_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ParamFieldKeyToggle_t qt_meta_stringdata_ParamFieldKeyToggle = {
    {
QT_MOC_LITERAL(0, 0, 19), // "ParamFieldKeyToggle"
QT_MOC_LITERAL(1, 20, 10), // "keyToggled"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 17), // "KeyBorderOffColor"
QT_MOC_LITERAL(4, 50, 16), // "KeyBorderOnColor"
QT_MOC_LITERAL(5, 67, 22), // "KeyBorderModifiedColor"
QT_MOC_LITERAL(6, 90, 23), // "KeyBorderInbetweenColor"
QT_MOC_LITERAL(7, 114, 23), // "KeyBorderHighlightColor"
QT_MOC_LITERAL(8, 138, 11), // "KeyOffColor"
QT_MOC_LITERAL(9, 150, 10), // "KeyOnColor"
QT_MOC_LITERAL(10, 161, 16), // "KeyModifiedColor"
QT_MOC_LITERAL(11, 178, 17), // "KeyInbetweenColor"
QT_MOC_LITERAL(12, 196, 17) // "KeyHighlightColor"

    },
    "ParamFieldKeyToggle\0keyToggled\0\0"
    "KeyBorderOffColor\0KeyBorderOnColor\0"
    "KeyBorderModifiedColor\0KeyBorderInbetweenColor\0"
    "KeyBorderHighlightColor\0KeyOffColor\0"
    "KeyOnColor\0KeyModifiedColor\0"
    "KeyInbetweenColor\0KeyHighlightColor"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ParamFieldKeyToggle[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
      10,   20, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void,

 // properties: name, type, flags
       3, QMetaType::QColor, 0x00095103,
       4, QMetaType::QColor, 0x00095103,
       5, QMetaType::QColor, 0x00095103,
       6, QMetaType::QColor, 0x00095103,
       7, QMetaType::QColor, 0x00095103,
       8, QMetaType::QColor, 0x00095103,
       9, QMetaType::QColor, 0x00095103,
      10, QMetaType::QColor, 0x00095103,
      11, QMetaType::QColor, 0x00095103,
      12, QMetaType::QColor, 0x00095103,

       0        // eod
};

void ParamFieldKeyToggle::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ParamFieldKeyToggle *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->keyToggled(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ParamFieldKeyToggle::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ParamFieldKeyToggle::keyToggled)) {
                *result = 0;
                return;
            }
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<ParamFieldKeyToggle *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QColor*>(_v) = _t->getKeyBorderOffColor(); break;
        case 1: *reinterpret_cast< QColor*>(_v) = _t->getKeyBorderOnColor(); break;
        case 2: *reinterpret_cast< QColor*>(_v) = _t->getKeyBorderModifiedColor(); break;
        case 3: *reinterpret_cast< QColor*>(_v) = _t->getKeyBorderInbetweenColor(); break;
        case 4: *reinterpret_cast< QColor*>(_v) = _t->getKeyBorderHighlightColor(); break;
        case 5: *reinterpret_cast< QColor*>(_v) = _t->getKeyOffColor(); break;
        case 6: *reinterpret_cast< QColor*>(_v) = _t->getKeyOnColor(); break;
        case 7: *reinterpret_cast< QColor*>(_v) = _t->getKeyModifiedColor(); break;
        case 8: *reinterpret_cast< QColor*>(_v) = _t->getKeyInbetweenColor(); break;
        case 9: *reinterpret_cast< QColor*>(_v) = _t->getKeyHighlightColor(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
        auto *_t = static_cast<ParamFieldKeyToggle *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setKeyBorderOffColor(*reinterpret_cast< QColor*>(_v)); break;
        case 1: _t->setKeyBorderOnColor(*reinterpret_cast< QColor*>(_v)); break;
        case 2: _t->setKeyBorderModifiedColor(*reinterpret_cast< QColor*>(_v)); break;
        case 3: _t->setKeyBorderInbetweenColor(*reinterpret_cast< QColor*>(_v)); break;
        case 4: _t->setKeyBorderHighlightColor(*reinterpret_cast< QColor*>(_v)); break;
        case 5: _t->setKeyOffColor(*reinterpret_cast< QColor*>(_v)); break;
        case 6: _t->setKeyOnColor(*reinterpret_cast< QColor*>(_v)); break;
        case 7: _t->setKeyModifiedColor(*reinterpret_cast< QColor*>(_v)); break;
        case 8: _t->setKeyInbetweenColor(*reinterpret_cast< QColor*>(_v)); break;
        case 9: _t->setKeyHighlightColor(*reinterpret_cast< QColor*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject ParamFieldKeyToggle::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_meta_stringdata_ParamFieldKeyToggle.data,
    qt_meta_data_ParamFieldKeyToggle,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *ParamFieldKeyToggle::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ParamFieldKeyToggle.stringdata0))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

int ParamFieldKeyToggle::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 < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 10;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void ParamFieldKeyToggle::keyToggled()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_MeasuredDoubleParamField_t {
    QByteArrayData data[4];
    char stringdata0[48];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_MeasuredDoubleParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_MeasuredDoubleParamField_t qt_meta_stringdata_MeasuredDoubleParamField = {
    {
QT_MOC_LITERAL(0, 0, 24), // "MeasuredDoubleParamField"
QT_MOC_LITERAL(1, 25, 8), // "onChange"
QT_MOC_LITERAL(2, 34, 0), // ""
QT_MOC_LITERAL(3, 35, 12) // "onKeyToggled"

    },
    "MeasuredDoubleParamField\0onChange\0\0"
    "onKeyToggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_MeasuredDoubleParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    2, 0x09 /* Protected */,
       3,    0,   27,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,

       0        // eod
};

void MeasuredDoubleParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<MeasuredDoubleParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->onKeyToggled(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject MeasuredDoubleParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<AnimatedParamField<double,TDoubleParamP>::staticMetaObject>(),
    qt_meta_stringdata_MeasuredDoubleParamField.data,
    qt_meta_data_MeasuredDoubleParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *MeasuredDoubleParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_MeasuredDoubleParamField.stringdata0))
        return static_cast<void*>(this);
    return AnimatedParamField<double,TDoubleParamP>::qt_metacast(_clname);
}

int MeasuredDoubleParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AnimatedParamField<double,TDoubleParamP>::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_MeasuredRangeParamField_t {
    QByteArrayData data[4];
    char stringdata0[47];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_MeasuredRangeParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_MeasuredRangeParamField_t qt_meta_stringdata_MeasuredRangeParamField = {
    {
QT_MOC_LITERAL(0, 0, 23), // "MeasuredRangeParamField"
QT_MOC_LITERAL(1, 24, 8), // "onChange"
QT_MOC_LITERAL(2, 33, 0), // ""
QT_MOC_LITERAL(3, 34, 12) // "onKeyToggled"

    },
    "MeasuredRangeParamField\0onChange\0\0"
    "onKeyToggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_MeasuredRangeParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    2, 0x09 /* Protected */,
       3,    0,   27,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,

       0        // eod
};

void MeasuredRangeParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<MeasuredRangeParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->onKeyToggled(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject MeasuredRangeParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<AnimatedParamField<DoublePair,TRangeParamP>::staticMetaObject>(),
    qt_meta_stringdata_MeasuredRangeParamField.data,
    qt_meta_data_MeasuredRangeParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *MeasuredRangeParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_MeasuredRangeParamField.stringdata0))
        return static_cast<void*>(this);
    return AnimatedParamField<DoublePair,TRangeParamP>::qt_metacast(_clname);
}

int MeasuredRangeParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AnimatedParamField<DoublePair,TRangeParamP>::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_PointParamField_t {
    QByteArrayData data[4];
    char stringdata0[39];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PointParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PointParamField_t qt_meta_stringdata_PointParamField = {
    {
QT_MOC_LITERAL(0, 0, 15), // "PointParamField"
QT_MOC_LITERAL(1, 16, 8), // "onChange"
QT_MOC_LITERAL(2, 25, 0), // ""
QT_MOC_LITERAL(3, 26, 12) // "onKeyToggled"

    },
    "PointParamField\0onChange\0\0onKeyToggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PointParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    2, 0x09 /* Protected */,
       3,    0,   27,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,

       0        // eod
};

void PointParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<PointParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->onKeyToggled(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject PointParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<AnimatedParamField<TPointD,TPointParamP>::staticMetaObject>(),
    qt_meta_stringdata_PointParamField.data,
    qt_meta_data_PointParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *PointParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_PointParamField.stringdata0))
        return static_cast<void*>(this);
    return AnimatedParamField<TPointD,TPointParamP>::qt_metacast(_clname);
}

int PointParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AnimatedParamField<TPointD,TPointParamP>::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_PixelParamField_t {
    QByteArrayData data[7];
    char stringdata0[65];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PixelParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PixelParamField_t qt_meta_stringdata_PixelParamField = {
    {
QT_MOC_LITERAL(0, 0, 15), // "PixelParamField"
QT_MOC_LITERAL(1, 16, 8), // "onChange"
QT_MOC_LITERAL(2, 25, 0), // ""
QT_MOC_LITERAL(3, 26, 8), // "TPixel32"
QT_MOC_LITERAL(4, 35, 5), // "value"
QT_MOC_LITERAL(5, 41, 10), // "isDragging"
QT_MOC_LITERAL(6, 52, 12) // "onKeyToggled"

    },
    "PixelParamField\0onChange\0\0TPixel32\0"
    "value\0isDragging\0onKeyToggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PixelParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    2,   24,    2, 0x09 /* Protected */,
       6,    0,   29,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, 0x80000000 | 3, QMetaType::Bool,    4,    5,
    QMetaType::Void,

       0        // eod
};

void PixelParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<PixelParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange((*reinterpret_cast< const TPixel32(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2]))); break;
        case 1: _t->onKeyToggled(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject PixelParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<AnimatedParamField<TPixel32,TPixelParamP>::staticMetaObject>(),
    qt_meta_stringdata_PixelParamField.data,
    qt_meta_data_PixelParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *PixelParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_PixelParamField.stringdata0))
        return static_cast<void*>(this);
    return AnimatedParamField<TPixel32,TPixelParamP>::qt_metacast(_clname);
}

int PixelParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AnimatedParamField<TPixel32,TPixelParamP>::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_RgbLinkButtons_t {
    QByteArrayData data[4];
    char stringdata0[56];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RgbLinkButtons_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RgbLinkButtons_t qt_meta_stringdata_RgbLinkButtons = {
    {
QT_MOC_LITERAL(0, 0, 14), // "RgbLinkButtons"
QT_MOC_LITERAL(1, 15, 19), // "onCopyButtonClicked"
QT_MOC_LITERAL(2, 35, 0), // ""
QT_MOC_LITERAL(3, 36, 19) // "onSwapButtonClicked"

    },
    "RgbLinkButtons\0onCopyButtonClicked\0\0"
    "onSwapButtonClicked"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RgbLinkButtons[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   24,    2, 0x09 /* Protected */,
       3,    0,   25,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void RgbLinkButtons::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<RgbLinkButtons *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onCopyButtonClicked(); break;
        case 1: _t->onSwapButtonClicked(); break;
        default: ;
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject RgbLinkButtons::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_meta_stringdata_RgbLinkButtons.data,
    qt_meta_data_RgbLinkButtons,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *RgbLinkButtons::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_RgbLinkButtons.stringdata0))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

int RgbLinkButtons::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 < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_SpectrumParamField_t {
    QByteArrayData data[8];
    char stringdata0[86];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_SpectrumParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_SpectrumParamField_t qt_meta_stringdata_SpectrumParamField = {
    {
QT_MOC_LITERAL(0, 0, 18), // "SpectrumParamField"
QT_MOC_LITERAL(1, 19, 12), // "onKeyToggled"
QT_MOC_LITERAL(2, 32, 0), // ""
QT_MOC_LITERAL(3, 33, 8), // "onChange"
QT_MOC_LITERAL(4, 42, 10), // "isDragging"
QT_MOC_LITERAL(5, 53, 10), // "onKeyAdded"
QT_MOC_LITERAL(6, 64, 8), // "keyIndex"
QT_MOC_LITERAL(7, 73, 12) // "onKeyRemoved"

    },
    "SpectrumParamField\0onKeyToggled\0\0"
    "onChange\0isDragging\0onKeyAdded\0keyIndex\0"
    "onKeyRemoved"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_SpectrumParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       4,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   34,    2, 0x09 /* Protected */,
       3,    1,   35,    2, 0x09 /* Protected */,
       5,    1,   38,    2, 0x09 /* Protected */,
       7,    1,   41,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void, QMetaType::Bool,    4,
    QMetaType::Void, QMetaType::Int,    6,
    QMetaType::Void, QMetaType::Int,    6,

       0        // eod
};

void SpectrumParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<SpectrumParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onKeyToggled(); break;
        case 1: _t->onChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 2: _t->onKeyAdded((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 3: _t->onKeyRemoved((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject SpectrumParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<AnimatedParamField<TSpectrum,TSpectrumParamP>::staticMetaObject>(),
    qt_meta_stringdata_SpectrumParamField.data,
    qt_meta_data_SpectrumParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *SpectrumParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_SpectrumParamField.stringdata0))
        return static_cast<void*>(this);
    return AnimatedParamField<TSpectrum,TSpectrumParamP>::qt_metacast(_clname);
}

int SpectrumParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AnimatedParamField<TSpectrum,TSpectrumParamP>::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
    return _id;
}
struct qt_meta_stringdata_ModeChangerParamField_t {
    QByteArrayData data[3];
    char stringdata0[35];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ModeChangerParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ModeChangerParamField_t qt_meta_stringdata_ModeChangerParamField = {
    {
QT_MOC_LITERAL(0, 0, 21), // "ModeChangerParamField"
QT_MOC_LITERAL(1, 22, 11), // "modeChanged"
QT_MOC_LITERAL(2, 34, 0) // ""

    },
    "ModeChangerParamField\0modeChanged\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ModeChangerParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void ModeChangerParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ModeChangerParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->modeChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ModeChangerParamField::*)(int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ModeChangerParamField::modeChanged)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject ModeChangerParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_ModeChangerParamField.data,
    qt_meta_data_ModeChangerParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *ModeChangerParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ModeChangerParamField.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int ModeChangerParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void ModeChangerParamField::modeChanged(int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_ModeSensitiveBox_t {
    QByteArrayData data[4];
    char stringdata0[37];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ModeSensitiveBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ModeSensitiveBox_t qt_meta_stringdata_ModeSensitiveBox = {
    {
QT_MOC_LITERAL(0, 0, 16), // "ModeSensitiveBox"
QT_MOC_LITERAL(1, 17, 13), // "onModeChanged"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 4) // "mode"

    },
    "ModeSensitiveBox\0onModeChanged\0\0mode"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ModeSensitiveBox[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    3,

       0        // eod
};

void ModeSensitiveBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ModeSensitiveBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onModeChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject ModeSensitiveBox::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_meta_stringdata_ModeSensitiveBox.data,
    qt_meta_data_ModeSensitiveBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *ModeSensitiveBox::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ModeSensitiveBox.stringdata0))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

int ModeSensitiveBox::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 < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_EnumParamField_t {
    QByteArrayData data[4];
    char stringdata0[29];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_EnumParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_EnumParamField_t qt_meta_stringdata_EnumParamField = {
    {
QT_MOC_LITERAL(0, 0, 14), // "EnumParamField"
QT_MOC_LITERAL(1, 15, 8), // "onChange"
QT_MOC_LITERAL(2, 24, 0), // ""
QT_MOC_LITERAL(3, 25, 3) // "str"

    },
    "EnumParamField\0onChange\0\0str"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_EnumParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,    3,

       0        // eod
};

void EnumParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<EnumParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject EnumParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<ModeChangerParamField::staticMetaObject>(),
    qt_meta_stringdata_EnumParamField.data,
    qt_meta_data_EnumParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *EnumParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_EnumParamField.stringdata0))
        return static_cast<void*>(this);
    return ModeChangerParamField::qt_metacast(_clname);
}

int EnumParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ModeChangerParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_BoolParamField_t {
    QByteArrayData data[5];
    char stringdata0[42];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_BoolParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_BoolParamField_t qt_meta_stringdata_BoolParamField = {
    {
QT_MOC_LITERAL(0, 0, 14), // "BoolParamField"
QT_MOC_LITERAL(1, 15, 7), // "toggled"
QT_MOC_LITERAL(2, 23, 0), // ""
QT_MOC_LITERAL(3, 24, 9), // "onToggled"
QT_MOC_LITERAL(4, 34, 7) // "checked"

    },
    "BoolParamField\0toggled\0\0onToggled\0"
    "checked"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_BoolParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,   24,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       3,    1,   27,    2, 0x09 /* Protected */,

 // signals: parameters
    QMetaType::Void, QMetaType::Bool,    2,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,    4,

       0        // eod
};

void BoolParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<BoolParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->toggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->onToggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (BoolParamField::*)(bool );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&BoolParamField::toggled)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject BoolParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<ModeChangerParamField::staticMetaObject>(),
    qt_meta_stringdata_BoolParamField.data,
    qt_meta_data_BoolParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *BoolParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_BoolParamField.stringdata0))
        return static_cast<void*>(this);
    return ModeChangerParamField::qt_metacast(_clname);
}

int BoolParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ModeChangerParamField::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void BoolParamField::toggled(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_IntParamField_t {
    QByteArrayData data[4];
    char stringdata0[35];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_IntParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_IntParamField_t qt_meta_stringdata_IntParamField = {
    {
QT_MOC_LITERAL(0, 0, 13), // "IntParamField"
QT_MOC_LITERAL(1, 14, 8), // "onChange"
QT_MOC_LITERAL(2, 23, 0), // ""
QT_MOC_LITERAL(3, 24, 10) // "isDragging"

    },
    "IntParamField\0onChange\0\0isDragging"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_IntParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    2, 0x09 /* Protected */,
       1,    0,   27,    2, 0x29 /* Protected | MethodCloned */,

 // slots: parameters
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void,

       0        // eod
};

void IntParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<IntParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->onChange(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject IntParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_IntParamField.data,
    qt_meta_data_IntParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *IntParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_IntParamField.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int IntParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
    return _id;
}
struct qt_meta_stringdata_component__MyTextEdit_t {
    QByteArrayData data[3];
    char stringdata0[30];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__MyTextEdit_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__MyTextEdit_t qt_meta_stringdata_component__MyTextEdit = {
    {
QT_MOC_LITERAL(0, 0, 21), // "component::MyTextEdit"
QT_MOC_LITERAL(1, 22, 6), // "edited"
QT_MOC_LITERAL(2, 29, 0) // ""

    },
    "component::MyTextEdit\0edited\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__MyTextEdit[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

void component::MyTextEdit::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<MyTextEdit *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->edited(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (MyTextEdit::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MyTextEdit::edited)) {
                *result = 0;
                return;
            }
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject component::MyTextEdit::staticMetaObject = { {
    QMetaObject::SuperData::link<QTextEdit::staticMetaObject>(),
    qt_meta_stringdata_component__MyTextEdit.data,
    qt_meta_data_component__MyTextEdit,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::MyTextEdit::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__MyTextEdit.stringdata0))
        return static_cast<void*>(this);
    return QTextEdit::qt_metacast(_clname);
}

int component::MyTextEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QTextEdit::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void component::MyTextEdit::edited()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_StringParamField_t {
    QByteArrayData data[3];
    char stringdata0[27];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_StringParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_StringParamField_t qt_meta_stringdata_StringParamField = {
    {
QT_MOC_LITERAL(0, 0, 16), // "StringParamField"
QT_MOC_LITERAL(1, 17, 8), // "onChange"
QT_MOC_LITERAL(2, 26, 0) // ""

    },
    "StringParamField\0onChange\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_StringParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

void StringParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<StringParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChange(); break;
        default: ;
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject StringParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_StringParamField.data,
    qt_meta_data_StringParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *StringParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_StringParamField.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int StringParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_FontParamField_t {
    QByteArrayData data[6];
    char stringdata0[54];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_FontParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FontParamField_t qt_meta_stringdata_FontParamField = {
    {
QT_MOC_LITERAL(0, 0, 14), // "FontParamField"
QT_MOC_LITERAL(1, 15, 10), // "findStyles"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 4), // "font"
QT_MOC_LITERAL(4, 32, 12), // "onSizeChange"
QT_MOC_LITERAL(5, 45, 8) // "onChange"

    },
    "FontParamField\0findStyles\0\0font\0"
    "onSizeChange\0onChange"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FontParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   29,    2, 0x09 /* Protected */,
       4,    1,   32,    2, 0x09 /* Protected */,
       5,    0,   35,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::QFont,    3,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,

       0        // eod
};

void FontParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<FontParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->findStyles((*reinterpret_cast< const QFont(*)>(_a[1]))); break;
        case 1: _t->onSizeChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 2: _t->onChange(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject FontParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_FontParamField.data,
    qt_meta_data_FontParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *FontParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_FontParamField.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int FontParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 3;
    }
    return _id;
}
struct qt_meta_stringdata_ToneCurveParamField_t {
    QByteArrayData data[10];
    char stringdata0[123];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ToneCurveParamField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ToneCurveParamField_t qt_meta_stringdata_ToneCurveParamField = {
    {
QT_MOC_LITERAL(0, 0, 19), // "ToneCurveParamField"
QT_MOC_LITERAL(1, 20, 16), // "onChannelChanged"
QT_MOC_LITERAL(2, 37, 0), // ""
QT_MOC_LITERAL(3, 38, 8), // "onChange"
QT_MOC_LITERAL(4, 47, 10), // "isDragging"
QT_MOC_LITERAL(5, 58, 12), // "onPointAdded"
QT_MOC_LITERAL(6, 71, 5), // "index"
QT_MOC_LITERAL(7, 77, 14), // "onPointRemoved"
QT_MOC_LITERAL(8, 92, 17), // "onIsLinearChanged"
QT_MOC_LITERAL(9, 110, 12) // "onKeyToggled"

    },
    "ToneCurveParamField\0onChannelChanged\0"
    "\0onChange\0isDragging\0onPointAdded\0"
    "index\0onPointRemoved\0onIsLinearChanged\0"
    "onKeyToggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ToneCurveParamField[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       6,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   44,    2, 0x09 /* Protected */,
       3,    1,   47,    2, 0x09 /* Protected */,
       5,    1,   50,    2, 0x09 /* Protected */,
       7,    1,   53,    2, 0x09 /* Protected */,
       8,    1,   56,    2, 0x09 /* Protected */,
       9,    0,   59,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,
    QMetaType::Void, QMetaType::Bool,    4,
    QMetaType::Void, QMetaType::Int,    6,
    QMetaType::Void, QMetaType::Int,    6,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void,

       0        // eod
};

void ToneCurveParamField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ToneCurveParamField *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onChannelChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 1: _t->onChange((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 2: _t->onPointAdded((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 3: _t->onPointRemoved((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 4: _t->onIsLinearChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 5: _t->onKeyToggled(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject ToneCurveParamField::staticMetaObject = { {
    QMetaObject::SuperData::link<AnimatedParamField<const QList<TPointD>,TToneCurveParamP>::staticMetaObject>(),
    qt_meta_stringdata_ToneCurveParamField.data,
    qt_meta_data_ToneCurveParamField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *ToneCurveParamField::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_ToneCurveParamField.stringdata0))
        return static_cast<void*>(this);
    return AnimatedParamField<const QList<TPointD>,TToneCurveParamP>::qt_metacast(_clname);
}

int ToneCurveParamField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = AnimatedParamField<const QList<TPointD>,TToneCurveParamP>::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 6)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 6;
    }
    return _id;
}
struct qt_meta_stringdata_component__LineEdit_double_t {
    QByteArrayData data[4];
    char stringdata0[46];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__LineEdit_double_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__LineEdit_double_t qt_meta_stringdata_component__LineEdit_double = {
    {
QT_MOC_LITERAL(0, 0, 26), // "component::LineEdit_double"
QT_MOC_LITERAL(1, 27, 12), // "update_value"
QT_MOC_LITERAL(2, 40, 0), // ""
QT_MOC_LITERAL(3, 41, 4) // "text"

    },
    "component::LineEdit_double\0update_value\0"
    "\0text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__LineEdit_double[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,    3,

       0        // eod
};

void component::LineEdit_double::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineEdit_double *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::LineEdit_double::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__LineEdit_double.data,
    qt_meta_data_component__LineEdit_double,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::LineEdit_double::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__LineEdit_double.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::LineEdit_double::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__Slider_double_t {
    QByteArrayData data[3];
    char stringdata0[39];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__Slider_double_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__Slider_double_t qt_meta_stringdata_component__Slider_double = {
    {
QT_MOC_LITERAL(0, 0, 24), // "component::Slider_double"
QT_MOC_LITERAL(1, 25, 12), // "update_value"
QT_MOC_LITERAL(2, 38, 0) // ""

    },
    "component::Slider_double\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__Slider_double[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void component::Slider_double::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<Slider_double *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::Slider_double::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__Slider_double.data,
    qt_meta_data_component__Slider_double,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::Slider_double::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__Slider_double.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::Slider_double::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__SpinBox_double_t {
    QByteArrayData data[3];
    char stringdata0[40];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__SpinBox_double_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__SpinBox_double_t qt_meta_stringdata_component__SpinBox_double = {
    {
QT_MOC_LITERAL(0, 0, 25), // "component::SpinBox_double"
QT_MOC_LITERAL(1, 26, 12), // "update_value"
QT_MOC_LITERAL(2, 39, 0) // ""

    },
    "component::SpinBox_double\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__SpinBox_double[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Double,    2,

       0        // eod
};

void component::SpinBox_double::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<SpinBox_double *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< double(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::SpinBox_double::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__SpinBox_double.data,
    qt_meta_data_component__SpinBox_double,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::SpinBox_double::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__SpinBox_double.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::SpinBox_double::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__LineEdit_int_t {
    QByteArrayData data[4];
    char stringdata0[43];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__LineEdit_int_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__LineEdit_int_t qt_meta_stringdata_component__LineEdit_int = {
    {
QT_MOC_LITERAL(0, 0, 23), // "component::LineEdit_int"
QT_MOC_LITERAL(1, 24, 12), // "update_value"
QT_MOC_LITERAL(2, 37, 0), // ""
QT_MOC_LITERAL(3, 38, 4) // "text"

    },
    "component::LineEdit_int\0update_value\0"
    "\0text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__LineEdit_int[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,    3,

       0        // eod
};

void component::LineEdit_int::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineEdit_int *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::LineEdit_int::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__LineEdit_int.data,
    qt_meta_data_component__LineEdit_int,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::LineEdit_int::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__LineEdit_int.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::LineEdit_int::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__Slider_int_t {
    QByteArrayData data[3];
    char stringdata0[36];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__Slider_int_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__Slider_int_t qt_meta_stringdata_component__Slider_int = {
    {
QT_MOC_LITERAL(0, 0, 21), // "component::Slider_int"
QT_MOC_LITERAL(1, 22, 12), // "update_value"
QT_MOC_LITERAL(2, 35, 0) // ""

    },
    "component::Slider_int\0update_value\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__Slider_int[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void component::Slider_int::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<Slider_int *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::Slider_int::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__Slider_int.data,
    qt_meta_data_component__Slider_int,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::Slider_int::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__Slider_int.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::Slider_int::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__SpinBox_int_t {
    QByteArrayData data[3];
    char stringdata0[37];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__SpinBox_int_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__SpinBox_int_t qt_meta_stringdata_component__SpinBox_int = {
    {
QT_MOC_LITERAL(0, 0, 22), // "component::SpinBox_int"
QT_MOC_LITERAL(1, 23, 12), // "update_value"
QT_MOC_LITERAL(2, 36, 0) // ""

    },
    "component::SpinBox_int\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__SpinBox_int[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void component::SpinBox_int::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<SpinBox_int *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::SpinBox_int::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__SpinBox_int.data,
    qt_meta_data_component__SpinBox_int,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::SpinBox_int::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__SpinBox_int.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::SpinBox_int::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__CheckBox_bool_t {
    QByteArrayData data[3];
    char stringdata0[39];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__CheckBox_bool_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__CheckBox_bool_t qt_meta_stringdata_component__CheckBox_bool = {
    {
QT_MOC_LITERAL(0, 0, 24), // "component::CheckBox_bool"
QT_MOC_LITERAL(1, 25, 12), // "update_value"
QT_MOC_LITERAL(2, 38, 0) // ""

    },
    "component::CheckBox_bool\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__CheckBox_bool[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void component::CheckBox_bool::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<CheckBox_bool *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::CheckBox_bool::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__CheckBox_bool.data,
    qt_meta_data_component__CheckBox_bool,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::CheckBox_bool::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__CheckBox_bool.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::CheckBox_bool::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__RadioButton_enum_t {
    QByteArrayData data[3];
    char stringdata0[42];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__RadioButton_enum_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__RadioButton_enum_t qt_meta_stringdata_component__RadioButton_enum = {
    {
QT_MOC_LITERAL(0, 0, 27), // "component::RadioButton_enum"
QT_MOC_LITERAL(1, 28, 12), // "update_value"
QT_MOC_LITERAL(2, 41, 0) // ""

    },
    "component::RadioButton_enum\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__RadioButton_enum[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void component::RadioButton_enum::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<RadioButton_enum *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::RadioButton_enum::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__RadioButton_enum.data,
    qt_meta_data_component__RadioButton_enum,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::RadioButton_enum::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__RadioButton_enum.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::RadioButton_enum::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__ComboBox_enum_t {
    QByteArrayData data[3];
    char stringdata0[39];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__ComboBox_enum_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__ComboBox_enum_t qt_meta_stringdata_component__ComboBox_enum = {
    {
QT_MOC_LITERAL(0, 0, 24), // "component::ComboBox_enum"
QT_MOC_LITERAL(1, 25, 12), // "update_value"
QT_MOC_LITERAL(2, 38, 0) // ""

    },
    "component::ComboBox_enum\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__ComboBox_enum[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::Int,    2,

       0        // eod
};

void component::ComboBox_enum::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ComboBox_enum *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::ComboBox_enum::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__ComboBox_enum.data,
    qt_meta_data_component__ComboBox_enum,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::ComboBox_enum::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__ComboBox_enum.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::ComboBox_enum::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
struct qt_meta_stringdata_component__LineEdit_string_t {
    QByteArrayData data[3];
    char stringdata0[41];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_component__LineEdit_string_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_component__LineEdit_string_t qt_meta_stringdata_component__LineEdit_string = {
    {
QT_MOC_LITERAL(0, 0, 26), // "component::LineEdit_string"
QT_MOC_LITERAL(1, 27, 12), // "update_value"
QT_MOC_LITERAL(2, 40, 0) // ""

    },
    "component::LineEdit_string\0update_value\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_component__LineEdit_string[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       1,   14, // methods
       0,    0, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x09 /* Protected */,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,    2,

       0        // eod
};

void component::LineEdit_string::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineEdit_string *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->update_value((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject component::LineEdit_string::staticMetaObject = { {
    QMetaObject::SuperData::link<ParamField::staticMetaObject>(),
    qt_meta_stringdata_component__LineEdit_string.data,
    qt_meta_data_component__LineEdit_string,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *component::LineEdit_string::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_component__LineEdit_string.stringdata0))
        return static_cast<void*>(this);
    return ParamField::qt_metacast(_clname);
}

int component::LineEdit_string::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ParamField::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 1;
    }
    return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
