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

#include "../../../../../kst-plot/src/libkstapp/viewitem.h"
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'viewitem.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3Kst8ViewItemE_t {};
} // unnamed namespace

template <> constexpr inline auto Kst::ViewItem::qt_create_metaobjectdata<qt_meta_tag_ZN3Kst8ViewItemE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kst::ViewItem",
        "geometryChanged",
        "",
        "creationComplete",
        "relativeSizeUpdated",
        "edit",
        "raise",
        "lower",
        "createAutoLayout",
        "createProtectedLayout",
        "createCustomLayout",
        "columns",
        "createOneColLayout",
        "createTwoColLayout",
        "createThreeColLayout",
        "sharePlots",
        "QPainter*",
        "painter",
        "creation",
        "remove",
        "resizeTopLeft",
        "QPointF",
        "offset",
        "resizeTopRight",
        "resizeBottomLeft",
        "resizeBottomRight",
        "resizeTop",
        "resizeBottom",
        "resizeLeft",
        "resizeRight",
        "setTopLeft",
        "point",
        "setTopRight",
        "setBottomLeft",
        "setBottomRight",
        "setTop",
        "y",
        "setBottom",
        "setLeft",
        "x",
        "setRight",
        "setLockPosToData",
        "lockPosToData",
        "customDimensionsTab",
        "clearEditDialogPtr",
        "creationPolygonChanged",
        "View::CreationEvent",
        "event",
        "creationPolygonChangedFixedAspect",
        "even",
        "aspect",
        "viewMouseModeChanged",
        "View::MouseMode",
        "oldMode",
        "updateView"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'geometryChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'creationComplete'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'relativeSizeUpdated'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'edit'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'raise'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'lower'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createAutoLayout'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createProtectedLayout'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createCustomLayout'
        QtMocHelpers::SlotData<void(int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'createCustomLayout'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'createOneColLayout'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createTwoColLayout'
        QtMocHelpers::SlotData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createThreeColLayout'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sharePlots'
        QtMocHelpers::SlotData<void(QPainter *, bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 }, { QMetaType::Bool, 18 },
        }}),
        // Slot 'remove'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resizeTopLeft'
        QtMocHelpers::SlotData<void(const QPointF &)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 22 },
        }}),
        // Slot 'resizeTopRight'
        QtMocHelpers::SlotData<void(const QPointF &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 22 },
        }}),
        // Slot 'resizeBottomLeft'
        QtMocHelpers::SlotData<void(const QPointF &)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 22 },
        }}),
        // Slot 'resizeBottomRight'
        QtMocHelpers::SlotData<void(const QPointF &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 22 },
        }}),
        // Slot 'resizeTop'
        QtMocHelpers::SlotData<void(qreal)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 22 },
        }}),
        // Slot 'resizeBottom'
        QtMocHelpers::SlotData<void(qreal)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 22 },
        }}),
        // Slot 'resizeLeft'
        QtMocHelpers::SlotData<void(qreal)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 22 },
        }}),
        // Slot 'resizeRight'
        QtMocHelpers::SlotData<void(qreal)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 22 },
        }}),
        // Slot 'setTopLeft'
        QtMocHelpers::SlotData<void(const QPointF &)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 31 },
        }}),
        // Slot 'setTopRight'
        QtMocHelpers::SlotData<void(const QPointF &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 31 },
        }}),
        // Slot 'setBottomLeft'
        QtMocHelpers::SlotData<void(const QPointF &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 31 },
        }}),
        // Slot 'setBottomRight'
        QtMocHelpers::SlotData<void(const QPointF &)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 21, 31 },
        }}),
        // Slot 'setTop'
        QtMocHelpers::SlotData<void(qreal)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 36 },
        }}),
        // Slot 'setBottom'
        QtMocHelpers::SlotData<void(qreal)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 36 },
        }}),
        // Slot 'setLeft'
        QtMocHelpers::SlotData<void(qreal)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 39 },
        }}),
        // Slot 'setRight'
        QtMocHelpers::SlotData<void(qreal)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 39 },
        }}),
        // Slot 'setLockPosToData'
        QtMocHelpers::SlotData<void(bool)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 42 },
        }}),
        // Slot 'customDimensionsTab'
        QtMocHelpers::SlotData<bool()>(43, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'clearEditDialogPtr'
        QtMocHelpers::SlotData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'creationPolygonChanged'
        QtMocHelpers::SlotData<void(View::CreationEvent)>(45, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Slot 'creationPolygonChangedFixedAspect'
        QtMocHelpers::SlotData<void(View::CreationEvent, qreal)>(48, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 46, 49 }, { QMetaType::QReal, 50 },
        }}),
        // Slot 'viewMouseModeChanged'
        QtMocHelpers::SlotData<void(View::MouseMode)>(51, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 52, 53 },
        }}),
        // Slot 'updateView'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ViewItem, qt_meta_tag_ZN3Kst8ViewItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kst::ViewItem::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst8ViewItemE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst8ViewItemE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Kst8ViewItemE_t>.metaTypes,
    nullptr
} };

void Kst::ViewItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ViewItem *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->geometryChanged(); break;
        case 1: _t->creationComplete(); break;
        case 2: _t->relativeSizeUpdated(); break;
        case 3: _t->edit(); break;
        case 4: _t->raise(); break;
        case 5: _t->lower(); break;
        case 6: _t->createAutoLayout(); break;
        case 7: _t->createProtectedLayout(); break;
        case 8: _t->createCustomLayout((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->createCustomLayout(); break;
        case 10: _t->createOneColLayout(); break;
        case 11: _t->createTwoColLayout(); break;
        case 12: _t->createThreeColLayout(); break;
        case 13: _t->sharePlots((*reinterpret_cast<std::add_pointer_t<QPainter*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 14: _t->remove(); break;
        case 15: _t->resizeTopLeft((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 16: _t->resizeTopRight((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 17: _t->resizeBottomLeft((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 18: _t->resizeBottomRight((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 19: _t->resizeTop((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 20: _t->resizeBottom((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 21: _t->resizeLeft((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 22: _t->resizeRight((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 23: _t->setTopLeft((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 24: _t->setTopRight((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 25: _t->setBottomLeft((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 26: _t->setBottomRight((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 27: _t->setTop((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 28: _t->setBottom((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 29: _t->setLeft((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 30: _t->setRight((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 31: _t->setLockPosToData((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 32: { bool _r = _t->customDimensionsTab();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 33: _t->clearEditDialogPtr(); break;
        case 34: _t->creationPolygonChanged((*reinterpret_cast<std::add_pointer_t<View::CreationEvent>>(_a[1]))); break;
        case 35: _t->creationPolygonChangedFixedAspect((*reinterpret_cast<std::add_pointer_t<View::CreationEvent>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2]))); break;
        case 36: _t->viewMouseModeChanged((*reinterpret_cast<std::add_pointer_t<View::MouseMode>>(_a[1]))); break;
        case 37: _t->updateView(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ViewItem::*)()>(_a, &ViewItem::geometryChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ViewItem::*)()>(_a, &ViewItem::creationComplete, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ViewItem::*)()>(_a, &ViewItem::relativeSizeUpdated, 2))
            return;
    }
}

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

void *Kst::ViewItem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst8ViewItemE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "NamedObject"))
        return static_cast< NamedObject*>(this);
    if (!strcmp(_clname, "QGraphicsRectItem"))
        return static_cast< QGraphicsRectItem*>(this);
    return QObject::qt_metacast(_clname);
}

int Kst::ViewItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 38)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 38;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 38)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 38;
    }
    return _id;
}

// SIGNAL 0
void Kst::ViewItem::geometryChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void Kst::ViewItem::creationComplete()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void Kst::ViewItem::relativeSizeUpdated()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN3Kst13CreateCommandE_t {};
} // unnamed namespace

template <> constexpr inline auto Kst::CreateCommand::qt_create_metaobjectdata<qt_meta_tag_ZN3Kst13CreateCommandE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kst::CreateCommand",
        "creationComplete",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'creationComplete'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CreateCommand, qt_meta_tag_ZN3Kst13CreateCommandE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kst::CreateCommand::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst13CreateCommandE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst13CreateCommandE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Kst13CreateCommandE_t>.metaTypes,
    nullptr
} };

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

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

void *Kst::CreateCommand::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst13CreateCommandE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "ViewCommand"))
        return static_cast< ViewCommand*>(this);
    return QObject::qt_metacast(_clname);
}

int Kst::CreateCommand::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3Kst16MimeDataViewItemE_t {};
} // unnamed namespace

template <> constexpr inline auto Kst::MimeDataViewItem::qt_create_metaobjectdata<qt_meta_tag_ZN3Kst16MimeDataViewItemE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Kst::MimeDataViewItem"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<MimeDataViewItem, qt_meta_tag_ZN3Kst16MimeDataViewItemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Kst::MimeDataViewItem::staticMetaObject = { {
    QMetaObject::SuperData::link<QMimeData::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst16MimeDataViewItemE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst16MimeDataViewItemE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Kst16MimeDataViewItemE_t>.metaTypes,
    nullptr
} };

void Kst::MimeDataViewItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<MimeDataViewItem *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *Kst::MimeDataViewItem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Kst16MimeDataViewItemE_t>.strings))
        return static_cast<void*>(this);
    return QMimeData::qt_metacast(_clname);
}

int Kst::MimeDataViewItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMimeData::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
