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

#include "../../src/connectagram-1.2.1/src/pattern.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'pattern.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.4.1. 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
struct qt_meta_stringdata_Pattern_t {
    QByteArrayData data[3];
    char stringdata[19];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_Pattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_Pattern_t qt_meta_stringdata_Pattern = {
    {
QT_MOC_LITERAL(0, 0, 7), // "Pattern"
QT_MOC_LITERAL(1, 8, 9), // "generated"
QT_MOC_LITERAL(2, 18, 0) // ""

    },
    "Pattern\0generated\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_Pattern[] = {

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

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

void Pattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Pattern *_t = static_cast<Pattern *>(_o);
        switch (_id) {
        case 0: _t->generated(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (Pattern::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&Pattern::generated)) {
                *result = 0;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject Pattern::staticMetaObject = {
    { &QThread::staticMetaObject, qt_meta_stringdata_Pattern.data,
      qt_meta_data_Pattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *Pattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_Pattern.stringdata))
        return static_cast<void*>(const_cast< Pattern*>(this));
    return QThread::qt_metacast(_clname);
}

int Pattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QThread::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 Pattern::generated()
{
    QMetaObject::activate(this, &staticMetaObject, 0, Q_NULLPTR);
}
struct qt_meta_stringdata_ChainPattern_t {
    QByteArrayData data[1];
    char stringdata[13];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ChainPattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ChainPattern_t qt_meta_stringdata_ChainPattern = {
    {
QT_MOC_LITERAL(0, 0, 12) // "ChainPattern"

    },
    "ChainPattern"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ChainPattern[] = {

 // content:
       7,       // 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 ChainPattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject ChainPattern::staticMetaObject = {
    { &Pattern::staticMetaObject, qt_meta_stringdata_ChainPattern.data,
      qt_meta_data_ChainPattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *ChainPattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_ChainPattern.stringdata))
        return static_cast<void*>(const_cast< ChainPattern*>(this));
    return Pattern::qt_metacast(_clname);
}

int ChainPattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Pattern::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_FencePattern_t {
    QByteArrayData data[1];
    char stringdata[13];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_FencePattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FencePattern_t qt_meta_stringdata_FencePattern = {
    {
QT_MOC_LITERAL(0, 0, 12) // "FencePattern"

    },
    "FencePattern"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FencePattern[] = {

 // content:
       7,       // 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 FencePattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject FencePattern::staticMetaObject = {
    { &Pattern::staticMetaObject, qt_meta_stringdata_FencePattern.data,
      qt_meta_data_FencePattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *FencePattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_FencePattern.stringdata))
        return static_cast<void*>(const_cast< FencePattern*>(this));
    return Pattern::qt_metacast(_clname);
}

int FencePattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Pattern::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_RingsPattern_t {
    QByteArrayData data[1];
    char stringdata[13];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_RingsPattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_RingsPattern_t qt_meta_stringdata_RingsPattern = {
    {
QT_MOC_LITERAL(0, 0, 12) // "RingsPattern"

    },
    "RingsPattern"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_RingsPattern[] = {

 // content:
       7,       // 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 RingsPattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject RingsPattern::staticMetaObject = {
    { &Pattern::staticMetaObject, qt_meta_stringdata_RingsPattern.data,
      qt_meta_data_RingsPattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *RingsPattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_RingsPattern.stringdata))
        return static_cast<void*>(const_cast< RingsPattern*>(this));
    return Pattern::qt_metacast(_clname);
}

int RingsPattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Pattern::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_StairsPattern_t {
    QByteArrayData data[1];
    char stringdata[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_StairsPattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_StairsPattern_t qt_meta_stringdata_StairsPattern = {
    {
QT_MOC_LITERAL(0, 0, 13) // "StairsPattern"

    },
    "StairsPattern"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_StairsPattern[] = {

 // content:
       7,       // 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 StairsPattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject StairsPattern::staticMetaObject = {
    { &Pattern::staticMetaObject, qt_meta_stringdata_StairsPattern.data,
      qt_meta_data_StairsPattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *StairsPattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_StairsPattern.stringdata))
        return static_cast<void*>(const_cast< StairsPattern*>(this));
    return Pattern::qt_metacast(_clname);
}

int StairsPattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Pattern::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_TwistyPattern_t {
    QByteArrayData data[1];
    char stringdata[14];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TwistyPattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TwistyPattern_t qt_meta_stringdata_TwistyPattern = {
    {
QT_MOC_LITERAL(0, 0, 13) // "TwistyPattern"

    },
    "TwistyPattern"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TwistyPattern[] = {

 // content:
       7,       // 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 TwistyPattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject TwistyPattern::staticMetaObject = {
    { &Pattern::staticMetaObject, qt_meta_stringdata_TwistyPattern.data,
      qt_meta_data_TwistyPattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *TwistyPattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_TwistyPattern.stringdata))
        return static_cast<void*>(const_cast< TwistyPattern*>(this));
    return Pattern::qt_metacast(_clname);
}

int TwistyPattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Pattern::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
struct qt_meta_stringdata_WavePattern_t {
    QByteArrayData data[1];
    char stringdata[12];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_WavePattern_t, stringdata) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_WavePattern_t qt_meta_stringdata_WavePattern = {
    {
QT_MOC_LITERAL(0, 0, 11) // "WavePattern"

    },
    "WavePattern"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_WavePattern[] = {

 // content:
       7,       // 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 WavePattern::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject WavePattern::staticMetaObject = {
    { &Pattern::staticMetaObject, qt_meta_stringdata_WavePattern.data,
      qt_meta_data_WavePattern,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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

void *WavePattern::qt_metacast(const char *_clname)
{
    if (!_clname) return Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_WavePattern.stringdata))
        return static_cast<void*>(const_cast< WavePattern*>(this));
    return Pattern::qt_metacast(_clname);
}

int WavePattern::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Pattern::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    return _id;
}
QT_END_MOC_NAMESPACE
