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

#include "../src/kolf-17.12.3/obstacles.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'obstacles.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.9.4. 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_Kolf__Bumper_t {
    QByteArrayData data[3];
    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_Kolf__Bumper_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__Bumper_t qt_meta_stringdata_Kolf__Bumper = {
    {
QT_MOC_LITERAL(0, 0, 12), // "Kolf::Bumper"
QT_MOC_LITERAL(1, 13, 13), // "turnBumperOff"
QT_MOC_LITERAL(2, 27, 0) // ""

    },
    "Kolf::Bumper\0turnBumperOff\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__Bumper[] = {

 // content:
       7,       // 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, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

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

const QMetaObject Kolf::Bumper::staticMetaObject = {
    { &EllipticalCanvasItem::staticMetaObject, qt_meta_stringdata_Kolf__Bumper.data,
      qt_meta_data_Kolf__Bumper,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::Bumper::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__Bumper.stringdata0))
        return static_cast<void*>(this);
    return EllipticalCanvasItem::qt_metacast(_clname);
}

int Kolf::Bumper::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = EllipticalCanvasItem::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_Kolf__WallOverlay_t {
    QByteArrayData data[4];
    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_Kolf__WallOverlay_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__WallOverlay_t qt_meta_stringdata_Kolf__WallOverlay = {
    {
QT_MOC_LITERAL(0, 0, 17), // "Kolf::WallOverlay"
QT_MOC_LITERAL(1, 18, 10), // "moveHandle"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 14) // "handleScenePos"

    },
    "Kolf::WallOverlay\0moveHandle\0\0"
    "handleScenePos"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__WallOverlay[] = {

 // content:
       7,       // 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, 0x08 /* Private */,

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

       0        // eod
};

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

const QMetaObject Kolf::WallOverlay::staticMetaObject = {
    { &Kolf::Overlay::staticMetaObject, qt_meta_stringdata_Kolf__WallOverlay.data,
      qt_meta_data_Kolf__WallOverlay,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::WallOverlay::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__WallOverlay.stringdata0))
        return static_cast<void*>(this);
    return Kolf::Overlay::qt_metacast(_clname);
}

int Kolf::WallOverlay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Kolf::Overlay::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_Kolf__RectangleItem_t {
    QByteArrayData data[7];
    char stringdata0[75];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kolf__RectangleItem_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__RectangleItem_t qt_meta_stringdata_Kolf__RectangleItem = {
    {
QT_MOC_LITERAL(0, 0, 19), // "Kolf::RectangleItem"
QT_MOC_LITERAL(1, 20, 11), // "wallChanged"
QT_MOC_LITERAL(2, 32, 0), // ""
QT_MOC_LITERAL(3, 33, 15), // "Kolf::WallIndex"
QT_MOC_LITERAL(4, 49, 5), // "index"
QT_MOC_LITERAL(5, 55, 7), // "hasWall"
QT_MOC_LITERAL(6, 63, 11) // "wallAllowed"

    },
    "Kolf::RectangleItem\0wallChanged\0\0"
    "Kolf::WallIndex\0index\0hasWall\0wallAllowed"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__RectangleItem[] = {

 // content:
       7,       // 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,    3,   19,    2, 0x06 /* Public */,

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

       0        // eod
};

void Kolf::RectangleItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        RectangleItem *_t = static_cast<RectangleItem *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->wallChanged((*reinterpret_cast< Kolf::WallIndex(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            typedef void (RectangleItem::*_t)(Kolf::WallIndex , bool , bool );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&RectangleItem::wallChanged)) {
                *result = 0;
                return;
            }
        }
    }
}

const QMetaObject Kolf::RectangleItem::staticMetaObject = {
    { &Tagaro::SpriteObjectItem::staticMetaObject, qt_meta_stringdata_Kolf__RectangleItem.data,
      qt_meta_data_Kolf__RectangleItem,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::RectangleItem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__RectangleItem.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "CanvasItem"))
        return static_cast< CanvasItem*>(this);
    return Tagaro::SpriteObjectItem::qt_metacast(_clname);
}

int Kolf::RectangleItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Tagaro::SpriteObjectItem::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 Kolf::RectangleItem::wallChanged(Kolf::WallIndex _t1, bool _t2, bool _t3)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)), const_cast<void*>(reinterpret_cast<const void*>(&_t3)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_Kolf__RectangleOverlay_t {
    QByteArrayData data[4];
    char stringdata0[50];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kolf__RectangleOverlay_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__RectangleOverlay_t qt_meta_stringdata_Kolf__RectangleOverlay = {
    {
QT_MOC_LITERAL(0, 0, 22), // "Kolf::RectangleOverlay"
QT_MOC_LITERAL(1, 23, 10), // "moveHandle"
QT_MOC_LITERAL(2, 34, 0), // ""
QT_MOC_LITERAL(3, 35, 14) // "handleScenePos"

    },
    "Kolf::RectangleOverlay\0moveHandle\0\0"
    "handleScenePos"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__RectangleOverlay[] = {

 // content:
       7,       // 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, 0x08 /* Private */,

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

       0        // eod
};

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

const QMetaObject Kolf::RectangleOverlay::staticMetaObject = {
    { &Kolf::Overlay::staticMetaObject, qt_meta_stringdata_Kolf__RectangleOverlay.data,
      qt_meta_data_Kolf__RectangleOverlay,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::RectangleOverlay::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__RectangleOverlay.stringdata0))
        return static_cast<void*>(this);
    return Kolf::Overlay::qt_metacast(_clname);
}

int Kolf::RectangleOverlay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Kolf::Overlay::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_Kolf__RectangleConfig_t {
    QByteArrayData data[8];
    char stringdata0[85];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kolf__RectangleConfig_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__RectangleConfig_t qt_meta_stringdata_Kolf__RectangleConfig = {
    {
QT_MOC_LITERAL(0, 0, 21), // "Kolf::RectangleConfig"
QT_MOC_LITERAL(1, 22, 7), // "setWall"
QT_MOC_LITERAL(2, 30, 0), // ""
QT_MOC_LITERAL(3, 31, 7), // "hasWall"
QT_MOC_LITERAL(4, 39, 11), // "wallChanged"
QT_MOC_LITERAL(5, 51, 15), // "Kolf::WallIndex"
QT_MOC_LITERAL(6, 67, 5), // "index"
QT_MOC_LITERAL(7, 73, 11) // "wallAllowed"

    },
    "Kolf::RectangleConfig\0setWall\0\0hasWall\0"
    "wallChanged\0Kolf::WallIndex\0index\0"
    "wallAllowed"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__RectangleConfig[] = {

 // content:
       7,       // 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 */,
       4,    3,   27,    2, 0x09 /* Protected */,

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

       0        // eod
};

void Kolf::RectangleConfig::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        RectangleConfig *_t = static_cast<RectangleConfig *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->setWall((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->wallChanged((*reinterpret_cast< Kolf::WallIndex(*)>(_a[1])),(*reinterpret_cast< bool(*)>(_a[2])),(*reinterpret_cast< bool(*)>(_a[3]))); break;
        default: ;
        }
    }
}

const QMetaObject Kolf::RectangleConfig::staticMetaObject = {
    { &Config::staticMetaObject, qt_meta_stringdata_Kolf__RectangleConfig.data,
      qt_meta_data_Kolf__RectangleConfig,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::RectangleConfig::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__RectangleConfig.stringdata0))
        return static_cast<void*>(this);
    return Config::qt_metacast(_clname);
}

int Kolf::RectangleConfig::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Config::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_Kolf__Floater_t {
    QByteArrayData data[4];
    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_Kolf__Floater_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__Floater_t qt_meta_stringdata_Kolf__Floater = {
    {
QT_MOC_LITERAL(0, 0, 13), // "Kolf::Floater"
QT_MOC_LITERAL(1, 14, 8), // "setSpeed"
QT_MOC_LITERAL(2, 23, 0), // ""
QT_MOC_LITERAL(3, 24, 5) // "speed"

    },
    "Kolf::Floater\0setSpeed\0\0speed"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__Floater[] = {

 // content:
       7,       // 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, 0x0a /* Public */,

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

       0        // eod
};

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

const QMetaObject Kolf::Floater::staticMetaObject = {
    { &Kolf::RectangleItem::staticMetaObject, qt_meta_stringdata_Kolf__Floater.data,
      qt_meta_data_Kolf__Floater,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::Floater::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__Floater.stringdata0))
        return static_cast<void*>(this);
    return Kolf::RectangleItem::qt_metacast(_clname);
}

int Kolf::Floater::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Kolf::RectangleItem::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_Kolf__FloaterOverlay_t {
    QByteArrayData data[4];
    char stringdata0[58];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kolf__FloaterOverlay_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__FloaterOverlay_t qt_meta_stringdata_Kolf__FloaterOverlay = {
    {
QT_MOC_LITERAL(0, 0, 20), // "Kolf::FloaterOverlay"
QT_MOC_LITERAL(1, 21, 20), // "moveMotionLineHandle"
QT_MOC_LITERAL(2, 42, 0), // ""
QT_MOC_LITERAL(3, 43, 14) // "handleScenePos"

    },
    "Kolf::FloaterOverlay\0moveMotionLineHandle\0"
    "\0handleScenePos"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__FloaterOverlay[] = {

 // content:
       7,       // 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, 0x08 /* Private */,

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

       0        // eod
};

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

const QMetaObject Kolf::FloaterOverlay::staticMetaObject = {
    { &Kolf::RectangleOverlay::staticMetaObject, qt_meta_stringdata_Kolf__FloaterOverlay.data,
      qt_meta_data_Kolf__FloaterOverlay,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::FloaterOverlay::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__FloaterOverlay.stringdata0))
        return static_cast<void*>(this);
    return Kolf::RectangleOverlay::qt_metacast(_clname);
}

int Kolf::FloaterOverlay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Kolf::RectangleOverlay::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_Kolf__Sign_t {
    QByteArrayData data[4];
    char stringdata0[25];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Kolf__Sign_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__Sign_t qt_meta_stringdata_Kolf__Sign = {
    {
QT_MOC_LITERAL(0, 0, 10), // "Kolf::Sign"
QT_MOC_LITERAL(1, 11, 7), // "setText"
QT_MOC_LITERAL(2, 19, 0), // ""
QT_MOC_LITERAL(3, 20, 4) // "text"

    },
    "Kolf::Sign\0setText\0\0text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__Sign[] = {

 // content:
       7,       // 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, 0x0a /* Public */,

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

       0        // eod
};

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

const QMetaObject Kolf::Sign::staticMetaObject = {
    { &Kolf::RectangleItem::staticMetaObject, qt_meta_stringdata_Kolf__Sign.data,
      qt_meta_data_Kolf__Sign,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::Sign::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__Sign.stringdata0))
        return static_cast<void*>(this);
    return Kolf::RectangleItem::qt_metacast(_clname);
}

int Kolf::Sign::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Kolf::RectangleItem::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_Kolf__Windmill_t {
    QByteArrayData data[6];
    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_Kolf__Windmill_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Kolf__Windmill_t qt_meta_stringdata_Kolf__Windmill = {
    {
QT_MOC_LITERAL(0, 0, 14), // "Kolf::Windmill"
QT_MOC_LITERAL(1, 15, 13), // "setGuardAtTop"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 10), // "guardAtTop"
QT_MOC_LITERAL(4, 41, 8), // "setSpeed"
QT_MOC_LITERAL(5, 50, 5) // "speed"

    },
    "Kolf::Windmill\0setGuardAtTop\0\0guardAtTop\0"
    "setSpeed\0speed"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Kolf__Windmill[] = {

 // content:
       7,       // 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, 0x0a /* Public */,
       4,    1,   27,    2, 0x0a /* Public */,

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

       0        // eod
};

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

const QMetaObject Kolf::Windmill::staticMetaObject = {
    { &Kolf::RectangleItem::staticMetaObject, qt_meta_stringdata_Kolf__Windmill.data,
      qt_meta_data_Kolf__Windmill,  qt_static_metacall, nullptr, nullptr}
};


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

void *Kolf::Windmill::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_Kolf__Windmill.stringdata0))
        return static_cast<void*>(this);
    return Kolf::RectangleItem::qt_metacast(_clname);
}

int Kolf::Windmill::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Kolf::RectangleItem::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;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
