/****************************************************************************
** Meta object code from reading C++ file 'tooloptions.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/tools/tooloptions.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'tooloptions.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_ToolOptionsBox_t {
    QByteArrayData data[1];
    char stringdata0[15];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ToolOptionsBox_t qt_meta_stringdata_ToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 14) // "ToolOptionsBox"

    },
    "ToolOptionsBox"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ToolOptionsBox[] = {

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

       0        // eod
};

void ToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject ToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<QFrame::staticMetaObject>(),
    qt_meta_stringdata_ToolOptionsBox.data,
    qt_meta_data_ToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int ToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QFrame::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_ArrowToolOptionsBox_t {
    QByteArrayData data[12];
    char stringdata0[218];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ArrowToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ArrowToolOptionsBox_t qt_meta_stringdata_ArrowToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 19), // "ArrowToolOptionsBox"
QT_MOC_LITERAL(1, 20, 15), // "onFrameSwitched"
QT_MOC_LITERAL(2, 36, 0), // ""
QT_MOC_LITERAL(3, 37, 27), // "updateStageObjectComboItems"
QT_MOC_LITERAL(4, 65, 31), // "syncCurrentStageObjectComboItem"
QT_MOC_LITERAL(5, 97, 34), // "onCurrentStageObjectComboActi..."
QT_MOC_LITERAL(6, 132, 5), // "index"
QT_MOC_LITERAL(7, 138, 20), // "onCurrentAxisChanged"
QT_MOC_LITERAL(8, 159, 16), // "onFlipHorizontal"
QT_MOC_LITERAL(9, 176, 14), // "onFlipVertical"
QT_MOC_LITERAL(10, 191, 12), // "onRotateLeft"
QT_MOC_LITERAL(11, 204, 13) // "onRotateRight"

    },
    "ArrowToolOptionsBox\0onFrameSwitched\0"
    "\0updateStageObjectComboItems\0"
    "syncCurrentStageObjectComboItem\0"
    "onCurrentStageObjectComboActivated\0"
    "index\0onCurrentAxisChanged\0onFlipHorizontal\0"
    "onFlipVertical\0onRotateLeft\0onRotateRight"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ArrowToolOptionsBox[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   59,    2, 0x09 /* Protected */,
       3,    0,   60,    2, 0x09 /* Protected */,
       4,    0,   61,    2, 0x09 /* Protected */,
       5,    1,   62,    2, 0x09 /* Protected */,
       7,    1,   65,    2, 0x09 /* Protected */,
       8,    0,   68,    2, 0x09 /* Protected */,
       9,    0,   69,    2, 0x09 /* Protected */,
      10,    0,   70,    2, 0x09 /* Protected */,
      11,    0,   71,    2, 0x09 /* Protected */,

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

       0        // eod
};

void ArrowToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ArrowToolOptionsBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onFrameSwitched(); break;
        case 1: _t->updateStageObjectComboItems(); break;
        case 2: _t->syncCurrentStageObjectComboItem(); break;
        case 3: _t->onCurrentStageObjectComboActivated((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 4: _t->onCurrentAxisChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 5: _t->onFlipHorizontal(); break;
        case 6: _t->onFlipVertical(); break;
        case 7: _t->onRotateLeft(); break;
        case 8: _t->onRotateRight(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject ArrowToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_ArrowToolOptionsBox.data,
    qt_meta_data_ArrowToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int ArrowToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
    return _id;
}
struct qt_meta_stringdata_DraggableIconView_t {
    QByteArrayData data[7];
    char stringdata0[78];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_DraggableIconView_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_DraggableIconView_t qt_meta_stringdata_DraggableIconView = {
    {
QT_MOC_LITERAL(0, 0, 17), // "DraggableIconView"
QT_MOC_LITERAL(1, 18, 12), // "onMousePress"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 12), // "QMouseEvent*"
QT_MOC_LITERAL(4, 45, 5), // "event"
QT_MOC_LITERAL(5, 51, 11), // "onMouseMove"
QT_MOC_LITERAL(6, 63, 14) // "onMouseRelease"

    },
    "DraggableIconView\0onMousePress\0\0"
    "QMouseEvent*\0event\0onMouseMove\0"
    "onMouseRelease"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_DraggableIconView[] = {

 // 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,    1,   29,    2, 0x06 /* Public */,
       5,    1,   32,    2, 0x06 /* Public */,
       6,    1,   35,    2, 0x06 /* Public */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 3,    4,
    QMetaType::Void, 0x80000000 | 3,    4,

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject DraggableIconView::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_meta_stringdata_DraggableIconView.data,
    qt_meta_data_DraggableIconView,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int DraggableIconView::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 DraggableIconView::onMousePress(QMouseEvent * _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void DraggableIconView::onMouseMove(QMouseEvent * _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void DraggableIconView::onMouseRelease(QMouseEvent * _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}
struct qt_meta_stringdata_IconViewField_t {
    QByteArrayData data[4];
    char stringdata0[59];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_IconViewField_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_IconViewField_t qt_meta_stringdata_IconViewField = {
    {
QT_MOC_LITERAL(0, 0, 13), // "IconViewField"
QT_MOC_LITERAL(1, 14, 14), // "ScalePegPixmap"
QT_MOC_LITERAL(2, 29, 14), // "RotationPixmap"
QT_MOC_LITERAL(3, 44, 14) // "PositionPixmap"

    },
    "IconViewField\0ScalePegPixmap\0"
    "RotationPixmap\0PositionPixmap"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_IconViewField[] = {

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

 // properties: name, type, flags
       1, QMetaType::QPixmap, 0x00095103,
       2, QMetaType::QPixmap, 0x00095103,
       3, QMetaType::QPixmap, 0x00095103,

       0        // eod
};

void IconViewField::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{

#ifndef QT_NO_PROPERTIES
    if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<IconViewField *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QPixmap*>(_v) = _t->getScalePegPixmap(); break;
        case 1: *reinterpret_cast< QPixmap*>(_v) = _t->getRotationPixmap(); break;
        case 2: *reinterpret_cast< QPixmap*>(_v) = _t->getPositionPixmap(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
        auto *_t = static_cast<IconViewField *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setScalePegPixmap(*reinterpret_cast< QPixmap*>(_v)); break;
        case 1: _t->setRotationPixmap(*reinterpret_cast< QPixmap*>(_v)); break;
        case 2: _t->setPositionPixmap(*reinterpret_cast< QPixmap*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject IconViewField::staticMetaObject = { {
    QMetaObject::SuperData::link<DraggableIconView::staticMetaObject>(),
    qt_meta_stringdata_IconViewField.data,
    qt_meta_data_IconViewField,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int IconViewField::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DraggableIconView::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    
#ifndef QT_NO_PROPERTIES
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 3;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_SelectionToolOptionsBox_t {
    QByteArrayData data[10];
    char stringdata0[164];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_SelectionToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_SelectionToolOptionsBox_t qt_meta_stringdata_SelectionToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 23), // "SelectionToolOptionsBox"
QT_MOC_LITERAL(1, 24, 20), // "onScaleXValueChanged"
QT_MOC_LITERAL(2, 45, 0), // ""
QT_MOC_LITERAL(3, 46, 9), // "addToUndo"
QT_MOC_LITERAL(4, 56, 20), // "onScaleYValueChanged"
QT_MOC_LITERAL(5, 77, 27), // "onSetSaveboxCheckboxChanged"
QT_MOC_LITERAL(6, 105, 16), // "onFlipHorizontal"
QT_MOC_LITERAL(7, 122, 14), // "onFlipVertical"
QT_MOC_LITERAL(8, 137, 12), // "onRotateLeft"
QT_MOC_LITERAL(9, 150, 13) // "onRotateRight"

    },
    "SelectionToolOptionsBox\0onScaleXValueChanged\0"
    "\0addToUndo\0onScaleYValueChanged\0"
    "onSetSaveboxCheckboxChanged\0"
    "onFlipHorizontal\0onFlipVertical\0"
    "onRotateLeft\0onRotateRight"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_SelectionToolOptionsBox[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    1,   59,    2, 0x09 /* Protected */,
       1,    0,   62,    2, 0x29 /* Protected | MethodCloned */,
       4,    1,   63,    2, 0x09 /* Protected */,
       4,    0,   66,    2, 0x29 /* Protected | MethodCloned */,
       5,    1,   67,    2, 0x09 /* Protected */,
       6,    0,   70,    2, 0x09 /* Protected */,
       7,    0,   71,    2, 0x09 /* Protected */,
       8,    0,   72,    2, 0x09 /* Protected */,
       9,    0,   73,    2, 0x09 /* Protected */,

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

       0        // eod
};

void SelectionToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<SelectionToolOptionsBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onScaleXValueChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->onScaleXValueChanged(); break;
        case 2: _t->onScaleYValueChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 3: _t->onScaleYValueChanged(); break;
        case 4: _t->onSetSaveboxCheckboxChanged((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 5: _t->onFlipHorizontal(); break;
        case 6: _t->onFlipVertical(); break;
        case 7: _t->onRotateLeft(); break;
        case 8: _t->onRotateRight(); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject SelectionToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_SelectionToolOptionsBox.data,
    qt_meta_data_SelectionToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

void *SelectionToolOptionsBox::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_SelectionToolOptionsBox.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "TProperty::Listener"))
        return static_cast< TProperty::Listener*>(this);
    return ToolOptionsBox::qt_metacast(_clname);
}

int SelectionToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
    return _id;
}
struct qt_meta_stringdata_GeometricToolOptionsBox_t {
    QByteArrayData data[5];
    char stringdata0[84];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_GeometricToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_GeometricToolOptionsBox_t qt_meta_stringdata_GeometricToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 23), // "GeometricToolOptionsBox"
QT_MOC_LITERAL(1, 24, 19), // "onShapeValueChanged"
QT_MOC_LITERAL(2, 44, 0), // ""
QT_MOC_LITERAL(3, 45, 19), // "onPencilModeToggled"
QT_MOC_LITERAL(4, 65, 18) // "onJoinStyleChanged"

    },
    "GeometricToolOptionsBox\0onShapeValueChanged\0"
    "\0onPencilModeToggled\0onJoinStyleChanged"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_GeometricToolOptionsBox[] = {

 // 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 */,
       3,    1,   32,    2, 0x09 /* Protected */,
       4,    1,   35,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject GeometricToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_GeometricToolOptionsBox.data,
    qt_meta_data_GeometricToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int GeometricToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_TypeToolOptionsBox_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_TypeToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TypeToolOptionsBox_t qt_meta_stringdata_TypeToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 18), // "TypeToolOptionsBox"
QT_MOC_LITERAL(1, 19, 14), // "onFieldChanged"
QT_MOC_LITERAL(2, 34, 0) // ""

    },
    "TypeToolOptionsBox\0onFieldChanged\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TypeToolOptionsBox[] = {

 // 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 TypeToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<TypeToolOptionsBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onFieldChanged(); break;
        default: ;
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject TypeToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_TypeToolOptionsBox.data,
    qt_meta_data_TypeToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int TypeToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_PaintbrushToolOptionsBox_t {
    QByteArrayData data[3];
    char stringdata0[45];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_PaintbrushToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PaintbrushToolOptionsBox_t qt_meta_stringdata_PaintbrushToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 24), // "PaintbrushToolOptionsBox"
QT_MOC_LITERAL(1, 25, 18), // "onColorModeChanged"
QT_MOC_LITERAL(2, 44, 0) // ""

    },
    "PaintbrushToolOptionsBox\0onColorModeChanged\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PaintbrushToolOptionsBox[] = {

 // 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 PaintbrushToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<PaintbrushToolOptionsBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onColorModeChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject PaintbrushToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_PaintbrushToolOptionsBox.data,
    qt_meta_data_PaintbrushToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int PaintbrushToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_FullColorFillToolOptionsBox_t {
    QByteArrayData data[1];
    char stringdata0[28];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_FullColorFillToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FullColorFillToolOptionsBox_t qt_meta_stringdata_FullColorFillToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 27) // "FullColorFillToolOptionsBox"

    },
    "FullColorFillToolOptionsBox"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FullColorFillToolOptionsBox[] = {

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

       0        // eod
};

void FullColorFillToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject FullColorFillToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_FullColorFillToolOptionsBox.data,
    qt_meta_data_FullColorFillToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int FullColorFillToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_FillToolOptionsBox_t {
    QByteArrayData data[6];
    char stringdata0[100];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_FillToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FillToolOptionsBox_t qt_meta_stringdata_FillToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 18), // "FillToolOptionsBox"
QT_MOC_LITERAL(1, 19, 18), // "onColorModeChanged"
QT_MOC_LITERAL(2, 38, 0), // ""
QT_MOC_LITERAL(3, 39, 17), // "onToolTypeChanged"
QT_MOC_LITERAL(4, 57, 18), // "onOnionModeToggled"
QT_MOC_LITERAL(5, 76, 23) // "onMultiFrameModeToggled"

    },
    "FillToolOptionsBox\0onColorModeChanged\0"
    "\0onToolTypeChanged\0onOnionModeToggled\0"
    "onMultiFrameModeToggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FillToolOptionsBox[] = {

 // 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,    1,   34,    2, 0x09 /* Protected */,
       3,    1,   37,    2, 0x09 /* Protected */,
       4,    1,   40,    2, 0x09 /* Protected */,
       5,    1,   43,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject FillToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_FillToolOptionsBox.data,
    qt_meta_data_FillToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int FillToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_BrushToolOptionsBox_t {
    QByteArrayData data[5];
    char stringdata0[68];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_BrushToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_BrushToolOptionsBox_t qt_meta_stringdata_BrushToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 19), // "BrushToolOptionsBox"
QT_MOC_LITERAL(1, 20, 19), // "onPencilModeToggled"
QT_MOC_LITERAL(2, 40, 0), // ""
QT_MOC_LITERAL(3, 41, 11), // "onAddPreset"
QT_MOC_LITERAL(4, 53, 14) // "onRemovePreset"

    },
    "BrushToolOptionsBox\0onPencilModeToggled\0"
    "\0onAddPreset\0onRemovePreset"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_BrushToolOptionsBox[] = {

 // 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 */,
       3,    0,   32,    2, 0x09 /* Protected */,
       4,    0,   33,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject BrushToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_BrushToolOptionsBox.data,
    qt_meta_data_BrushToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int BrushToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_EraserToolOptionsBox_t {
    QByteArrayData data[5];
    char stringdata0[79];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_EraserToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_EraserToolOptionsBox_t qt_meta_stringdata_EraserToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 20), // "EraserToolOptionsBox"
QT_MOC_LITERAL(1, 21, 19), // "onPencilModeToggled"
QT_MOC_LITERAL(2, 41, 0), // ""
QT_MOC_LITERAL(3, 42, 17), // "onToolTypeChanged"
QT_MOC_LITERAL(4, 60, 18) // "onColorModeChanged"

    },
    "EraserToolOptionsBox\0onPencilModeToggled\0"
    "\0onToolTypeChanged\0onColorModeChanged"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_EraserToolOptionsBox[] = {

 // 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 */,
       3,    1,   32,    2, 0x09 /* Protected */,
       4,    1,   35,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject EraserToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_EraserToolOptionsBox.data,
    qt_meta_data_EraserToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int EraserToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_FingerToolOptionsBox_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_FingerToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FingerToolOptionsBox_t qt_meta_stringdata_FingerToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 20), // "FingerToolOptionsBox"
QT_MOC_LITERAL(1, 21, 18), // "onColorModeChanged"
QT_MOC_LITERAL(2, 40, 0) // ""

    },
    "FingerToolOptionsBox\0onColorModeChanged\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FingerToolOptionsBox[] = {

 // 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 FingerToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<FingerToolOptionsBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onColorModeChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject FingerToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_FingerToolOptionsBox.data,
    qt_meta_data_FingerToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int FingerToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_RulerToolOptionsBox_t {
    QByteArrayData data[1];
    char stringdata0[20];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RulerToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RulerToolOptionsBox_t qt_meta_stringdata_RulerToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 19) // "RulerToolOptionsBox"

    },
    "RulerToolOptionsBox"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RulerToolOptionsBox[] = {

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

       0        // eod
};

void RulerToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject RulerToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_RulerToolOptionsBox.data,
    qt_meta_data_RulerToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int RulerToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_TapeToolOptionsBox_t {
    QByteArrayData data[5];
    char stringdata0[81];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TapeToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TapeToolOptionsBox_t qt_meta_stringdata_TapeToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 18), // "TapeToolOptionsBox"
QT_MOC_LITERAL(1, 19, 17), // "onToolTypeChanged"
QT_MOC_LITERAL(2, 37, 0), // ""
QT_MOC_LITERAL(3, 38, 17), // "onToolModeChanged"
QT_MOC_LITERAL(4, 56, 24) // "onJoinStrokesModeChanged"

    },
    "TapeToolOptionsBox\0onToolTypeChanged\0"
    "\0onToolModeChanged\0onJoinStrokesModeChanged"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TapeToolOptionsBox[] = {

 // 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 */,
       3,    1,   32,    2, 0x09 /* Protected */,
       4,    0,   35,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject TapeToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_TapeToolOptionsBox.data,
    qt_meta_data_TapeToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int TapeToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_RGBPickerToolOptionsBox_t {
    QByteArrayData data[3];
    char stringdata0[49];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RGBPickerToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RGBPickerToolOptionsBox_t qt_meta_stringdata_RGBPickerToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 23), // "RGBPickerToolOptionsBox"
QT_MOC_LITERAL(1, 24, 23), // "updateRealTimePickLabel"
QT_MOC_LITERAL(2, 48, 0) // ""

    },
    "RGBPickerToolOptionsBox\0updateRealTimePickLabel\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RGBPickerToolOptionsBox[] = {

 // 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::QColor,    2,

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject RGBPickerToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_RGBPickerToolOptionsBox.data,
    qt_meta_data_RGBPickerToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int RGBPickerToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_StylePickerToolOptionsBox_t {
    QByteArrayData data[3];
    char stringdata0[51];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_StylePickerToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_StylePickerToolOptionsBox_t qt_meta_stringdata_StylePickerToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 25), // "StylePickerToolOptionsBox"
QT_MOC_LITERAL(1, 26, 23), // "updateRealTimePickLabel"
QT_MOC_LITERAL(2, 50, 0) // ""

    },
    "StylePickerToolOptionsBox\0"
    "updateRealTimePickLabel\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_StylePickerToolOptionsBox[] = {

 // 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,    3,   19,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject StylePickerToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_StylePickerToolOptionsBox.data,
    qt_meta_data_StylePickerToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int StylePickerToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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_ShiftTraceToolOptionBox_t {
    QByteArrayData data[7];
    char stringdata0[138];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ShiftTraceToolOptionBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ShiftTraceToolOptionBox_t qt_meta_stringdata_ShiftTraceToolOptionBox = {
    {
QT_MOC_LITERAL(0, 0, 23), // "ShiftTraceToolOptionBox"
QT_MOC_LITERAL(1, 24, 26), // "onResetPrevGhostBtnPressed"
QT_MOC_LITERAL(2, 51, 0), // ""
QT_MOC_LITERAL(3, 52, 27), // "onResetAfterGhostBtnPressed"
QT_MOC_LITERAL(4, 80, 21), // "onPrevRadioBtnClicked"
QT_MOC_LITERAL(5, 102, 22), // "onAfterRadioBtnClicked"
QT_MOC_LITERAL(6, 125, 12) // "updateColors"

    },
    "ShiftTraceToolOptionBox\0"
    "onResetPrevGhostBtnPressed\0\0"
    "onResetAfterGhostBtnPressed\0"
    "onPrevRadioBtnClicked\0onAfterRadioBtnClicked\0"
    "updateColors"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ShiftTraceToolOptionBox[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   39,    2, 0x09 /* Protected */,
       3,    0,   40,    2, 0x09 /* Protected */,
       4,    0,   41,    2, 0x09 /* Protected */,
       5,    0,   42,    2, 0x09 /* Protected */,
       6,    0,   43,    2, 0x09 /* Protected */,

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

       0        // eod
};

void ShiftTraceToolOptionBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ShiftTraceToolOptionBox *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->onResetPrevGhostBtnPressed(); break;
        case 1: _t->onResetAfterGhostBtnPressed(); break;
        case 2: _t->onPrevRadioBtnClicked(); break;
        case 3: _t->onAfterRadioBtnClicked(); break;
        case 4: _t->updateColors(); break;
        default: ;
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject ShiftTraceToolOptionBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_ShiftTraceToolOptionBox.data,
    qt_meta_data_ShiftTraceToolOptionBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int ShiftTraceToolOptionBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::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;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}
struct qt_meta_stringdata_ZoomToolOptionsBox_t {
    QByteArrayData data[1];
    char stringdata0[19];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ZoomToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ZoomToolOptionsBox_t qt_meta_stringdata_ZoomToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 18) // "ZoomToolOptionsBox"

    },
    "ZoomToolOptionsBox"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ZoomToolOptionsBox[] = {

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

       0        // eod
};

void ZoomToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject ZoomToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_ZoomToolOptionsBox.data,
    qt_meta_data_ZoomToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int ZoomToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_RotateToolOptionsBox_t {
    QByteArrayData data[1];
    char stringdata0[21];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RotateToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RotateToolOptionsBox_t qt_meta_stringdata_RotateToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 20) // "RotateToolOptionsBox"

    },
    "RotateToolOptionsBox"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RotateToolOptionsBox[] = {

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

       0        // eod
};

void RotateToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject RotateToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_RotateToolOptionsBox.data,
    qt_meta_data_RotateToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int RotateToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_HandToolOptionsBox_t {
    QByteArrayData data[1];
    char stringdata0[19];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_HandToolOptionsBox_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_HandToolOptionsBox_t qt_meta_stringdata_HandToolOptionsBox = {
    {
QT_MOC_LITERAL(0, 0, 18) // "HandToolOptionsBox"

    },
    "HandToolOptionsBox"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_HandToolOptionsBox[] = {

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

       0        // eod
};

void HandToolOptionsBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    (void)_o;
    (void)_id;
    (void)_c;
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject HandToolOptionsBox::staticMetaObject = { {
    QMetaObject::SuperData::link<ToolOptionsBox::staticMetaObject>(),
    qt_meta_stringdata_HandToolOptionsBox.data,
    qt_meta_data_HandToolOptionsBox,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int HandToolOptionsBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = ToolOptionsBox::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_ToolOptions_t {
    QByteArrayData data[7];
    char stringdata0[102];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ToolOptions_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ToolOptions_t qt_meta_stringdata_ToolOptions = {
    {
QT_MOC_LITERAL(0, 0, 11), // "ToolOptions"
QT_MOC_LITERAL(1, 12, 15), // "newPanelCreated"
QT_MOC_LITERAL(2, 28, 0), // ""
QT_MOC_LITERAL(3, 29, 14), // "onToolSwitched"
QT_MOC_LITERAL(4, 44, 23), // "onToolOptionsBoxChanged"
QT_MOC_LITERAL(5, 68, 13), // "onToolChanged"
QT_MOC_LITERAL(6, 82, 19) // "onStageObjectChange"

    },
    "ToolOptions\0newPanelCreated\0\0"
    "onToolSwitched\0onToolOptionsBoxChanged\0"
    "onToolChanged\0onStageObjectChange"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ToolOptions[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       3,    0,   40,    2, 0x0a /* Public */,
       4,    0,   41,    2, 0x0a /* Public */,
       5,    0,   42,    2, 0x0a /* Public */,
       6,    0,   43,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void,

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

       0        // eod
};

void ToolOptions::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ToolOptions *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->newPanelCreated(); break;
        case 1: _t->onToolSwitched(); break;
        case 2: _t->onToolOptionsBoxChanged(); break;
        case 3: _t->onToolChanged(); break;
        case 4: _t->onStageObjectChange(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ToolOptions::*)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ToolOptions::newPanelCreated)) {
                *result = 0;
                return;
            }
        }
    }
    (void)_a;
}

QT_INIT_METAOBJECT const QMetaObject ToolOptions::staticMetaObject = { {
    QMetaObject::SuperData::link<QFrame::staticMetaObject>(),
    qt_meta_stringdata_ToolOptions.data,
    qt_meta_data_ToolOptions,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void ToolOptions::newPanelCreated()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
