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

#include <memory>
#include "../../../../../../../gr-qtgui/include/gnuradio/qtgui/form_menus.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'form_menus.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.18. 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_LineColorMenu_t {
    QByteArrayData data[17];
    char stringdata0[157];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LineColorMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LineColorMenu_t qt_meta_stringdata_LineColorMenu = {
    {
QT_MOC_LITERAL(0, 0, 13), // "LineColorMenu"
QT_MOC_LITERAL(1, 14, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 27, 0), // ""
QT_MOC_LITERAL(3, 28, 5), // "which"
QT_MOC_LITERAL(4, 34, 4), // "name"
QT_MOC_LITERAL(5, 39, 7), // "getBlue"
QT_MOC_LITERAL(6, 47, 6), // "getRed"
QT_MOC_LITERAL(7, 54, 8), // "getGreen"
QT_MOC_LITERAL(8, 63, 8), // "getBlack"
QT_MOC_LITERAL(9, 72, 7), // "getCyan"
QT_MOC_LITERAL(10, 80, 10), // "getMagenta"
QT_MOC_LITERAL(11, 91, 9), // "getYellow"
QT_MOC_LITERAL(12, 101, 7), // "getGray"
QT_MOC_LITERAL(13, 109, 10), // "getDarkRed"
QT_MOC_LITERAL(14, 120, 12), // "getDarkGreen"
QT_MOC_LITERAL(15, 133, 11), // "getDarkBlue"
QT_MOC_LITERAL(16, 145, 11) // "getDarkGray"

    },
    "LineColorMenu\0whichTrigger\0\0which\0"
    "name\0getBlue\0getRed\0getGreen\0getBlack\0"
    "getCyan\0getMagenta\0getYellow\0getGray\0"
    "getDarkRed\0getDarkGreen\0getDarkBlue\0"
    "getDarkGray"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LineColorMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   84,    2, 0x0a /* Public */,
       6,    0,   85,    2, 0x0a /* Public */,
       7,    0,   86,    2, 0x0a /* Public */,
       8,    0,   87,    2, 0x0a /* Public */,
       9,    0,   88,    2, 0x0a /* Public */,
      10,    0,   89,    2, 0x0a /* Public */,
      11,    0,   90,    2, 0x0a /* Public */,
      12,    0,   91,    2, 0x0a /* Public */,
      13,    0,   92,    2, 0x0a /* Public */,
      14,    0,   93,    2, 0x0a /* Public */,
      15,    0,   94,    2, 0x0a /* Public */,
      16,    0,   95,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::QString,    3,    4,

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

       0        // eod
};

void LineColorMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineColorMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        case 1: _t->getBlue(); break;
        case 2: _t->getRed(); break;
        case 3: _t->getGreen(); break;
        case 4: _t->getBlack(); break;
        case 5: _t->getCyan(); break;
        case 6: _t->getMagenta(); break;
        case 7: _t->getYellow(); break;
        case 8: _t->getGray(); break;
        case 9: _t->getDarkRed(); break;
        case 10: _t->getDarkGreen(); break;
        case 11: _t->getDarkBlue(); break;
        case 12: _t->getDarkGray(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (LineColorMenu::*)(unsigned int , const QString & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&LineColorMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject LineColorMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_LineColorMenu.data,
    qt_meta_data_LineColorMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void LineColorMenu::whichTrigger(unsigned int _t1, const QString & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_LineWidthMenu_t {
    QByteArrayData data[15];
    char stringdata0[119];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LineWidthMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LineWidthMenu_t qt_meta_stringdata_LineWidthMenu = {
    {
QT_MOC_LITERAL(0, 0, 13), // "LineWidthMenu"
QT_MOC_LITERAL(1, 14, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 27, 0), // ""
QT_MOC_LITERAL(3, 28, 5), // "which"
QT_MOC_LITERAL(4, 34, 5), // "width"
QT_MOC_LITERAL(5, 40, 6), // "getOne"
QT_MOC_LITERAL(6, 47, 6), // "getTwo"
QT_MOC_LITERAL(7, 54, 8), // "getThree"
QT_MOC_LITERAL(8, 63, 7), // "getFour"
QT_MOC_LITERAL(9, 71, 7), // "getFive"
QT_MOC_LITERAL(10, 79, 6), // "getSix"
QT_MOC_LITERAL(11, 86, 8), // "getSeven"
QT_MOC_LITERAL(12, 95, 8), // "getEight"
QT_MOC_LITERAL(13, 104, 7), // "getNine"
QT_MOC_LITERAL(14, 112, 6) // "getTen"

    },
    "LineWidthMenu\0whichTrigger\0\0which\0"
    "width\0getOne\0getTwo\0getThree\0getFour\0"
    "getFive\0getSix\0getSeven\0getEight\0"
    "getNine\0getTen"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LineWidthMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   74,    2, 0x0a /* Public */,
       6,    0,   75,    2, 0x0a /* Public */,
       7,    0,   76,    2, 0x0a /* Public */,
       8,    0,   77,    2, 0x0a /* Public */,
       9,    0,   78,    2, 0x0a /* Public */,
      10,    0,   79,    2, 0x0a /* Public */,
      11,    0,   80,    2, 0x0a /* Public */,
      12,    0,   81,    2, 0x0a /* Public */,
      13,    0,   82,    2, 0x0a /* Public */,
      14,    0,   83,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    4,

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

       0        // eod
};

void LineWidthMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineWidthMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: _t->getOne(); break;
        case 2: _t->getTwo(); break;
        case 3: _t->getThree(); break;
        case 4: _t->getFour(); break;
        case 5: _t->getFive(); break;
        case 6: _t->getSix(); break;
        case 7: _t->getSeven(); break;
        case 8: _t->getEight(); break;
        case 9: _t->getNine(); break;
        case 10: _t->getTen(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (LineWidthMenu::*)(unsigned int , unsigned int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&LineWidthMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject LineWidthMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_LineWidthMenu.data,
    qt_meta_data_LineWidthMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void LineWidthMenu::whichTrigger(unsigned int _t1, unsigned int _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_LineStyleMenu_t {
    QByteArrayData data[11];
    char stringdata0[105];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LineStyleMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LineStyleMenu_t qt_meta_stringdata_LineStyleMenu = {
    {
QT_MOC_LITERAL(0, 0, 13), // "LineStyleMenu"
QT_MOC_LITERAL(1, 14, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 27, 0), // ""
QT_MOC_LITERAL(3, 28, 5), // "which"
QT_MOC_LITERAL(4, 34, 12), // "Qt::PenStyle"
QT_MOC_LITERAL(5, 47, 7), // "getNone"
QT_MOC_LITERAL(6, 55, 8), // "getSolid"
QT_MOC_LITERAL(7, 64, 7), // "getDash"
QT_MOC_LITERAL(8, 72, 7), // "getDots"
QT_MOC_LITERAL(9, 80, 10), // "getDashDot"
QT_MOC_LITERAL(10, 91, 13) // "getDashDotDot"

    },
    "LineStyleMenu\0whichTrigger\0\0which\0"
    "Qt::PenStyle\0getNone\0getSolid\0getDash\0"
    "getDots\0getDashDot\0getDashDotDot"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LineStyleMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   54,    2, 0x0a /* Public */,
       6,    0,   55,    2, 0x0a /* Public */,
       7,    0,   56,    2, 0x0a /* Public */,
       8,    0,   57,    2, 0x0a /* Public */,
       9,    0,   58,    2, 0x0a /* Public */,
      10,    0,   59,    2, 0x0a /* Public */,

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

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

       0        // eod
};

void LineStyleMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineStyleMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< Qt::PenStyle(*)>(_a[2]))); break;
        case 1: _t->getNone(); break;
        case 2: _t->getSolid(); break;
        case 3: _t->getDash(); break;
        case 4: _t->getDots(); break;
        case 5: _t->getDashDot(); break;
        case 6: _t->getDashDotDot(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (LineStyleMenu::*)(unsigned int , Qt::PenStyle );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&LineStyleMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject LineStyleMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_LineStyleMenu.data,
    qt_meta_data_LineStyleMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void LineStyleMenu::whichTrigger(unsigned int _t1, Qt::PenStyle _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_LineMarkerMenu_t {
    QByteArrayData data[20];
    char stringdata0[206];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LineMarkerMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LineMarkerMenu_t qt_meta_stringdata_LineMarkerMenu = {
    {
QT_MOC_LITERAL(0, 0, 14), // "LineMarkerMenu"
QT_MOC_LITERAL(1, 15, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 28, 0), // ""
QT_MOC_LITERAL(3, 29, 5), // "which"
QT_MOC_LITERAL(4, 35, 16), // "QwtSymbol::Style"
QT_MOC_LITERAL(5, 52, 7), // "getNone"
QT_MOC_LITERAL(6, 60, 9), // "getCircle"
QT_MOC_LITERAL(7, 70, 7), // "getRect"
QT_MOC_LITERAL(8, 78, 10), // "getDiamond"
QT_MOC_LITERAL(9, 89, 11), // "getTriangle"
QT_MOC_LITERAL(10, 101, 12), // "getDTriangle"
QT_MOC_LITERAL(11, 114, 12), // "getLTriangle"
QT_MOC_LITERAL(12, 127, 12), // "getRTriangle"
QT_MOC_LITERAL(13, 140, 8), // "getCross"
QT_MOC_LITERAL(14, 149, 9), // "getXCross"
QT_MOC_LITERAL(15, 159, 8), // "getHLine"
QT_MOC_LITERAL(16, 168, 8), // "getVLine"
QT_MOC_LITERAL(17, 177, 8), // "getStar1"
QT_MOC_LITERAL(18, 186, 8), // "getStar2"
QT_MOC_LITERAL(19, 195, 10) // "getHexagon"

    },
    "LineMarkerMenu\0whichTrigger\0\0which\0"
    "QwtSymbol::Style\0getNone\0getCircle\0"
    "getRect\0getDiamond\0getTriangle\0"
    "getDTriangle\0getLTriangle\0getRTriangle\0"
    "getCross\0getXCross\0getHLine\0getVLine\0"
    "getStar1\0getStar2\0getHexagon"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LineMarkerMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   99,    2, 0x0a /* Public */,
       6,    0,  100,    2, 0x0a /* Public */,
       7,    0,  101,    2, 0x0a /* Public */,
       8,    0,  102,    2, 0x0a /* Public */,
       9,    0,  103,    2, 0x0a /* Public */,
      10,    0,  104,    2, 0x0a /* Public */,
      11,    0,  105,    2, 0x0a /* Public */,
      12,    0,  106,    2, 0x0a /* Public */,
      13,    0,  107,    2, 0x0a /* Public */,
      14,    0,  108,    2, 0x0a /* Public */,
      15,    0,  109,    2, 0x0a /* Public */,
      16,    0,  110,    2, 0x0a /* Public */,
      17,    0,  111,    2, 0x0a /* Public */,
      18,    0,  112,    2, 0x0a /* Public */,
      19,    0,  113,    2, 0x0a /* Public */,

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

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

       0        // eod
};

void LineMarkerMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineMarkerMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< QwtSymbol::Style(*)>(_a[2]))); break;
        case 1: _t->getNone(); break;
        case 2: _t->getCircle(); break;
        case 3: _t->getRect(); break;
        case 4: _t->getDiamond(); break;
        case 5: _t->getTriangle(); break;
        case 6: _t->getDTriangle(); break;
        case 7: _t->getLTriangle(); break;
        case 8: _t->getRTriangle(); break;
        case 9: _t->getCross(); break;
        case 10: _t->getXCross(); break;
        case 11: _t->getHLine(); break;
        case 12: _t->getVLine(); break;
        case 13: _t->getStar1(); break;
        case 14: _t->getStar2(); break;
        case 15: _t->getHexagon(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (LineMarkerMenu::*)(unsigned int , QwtSymbol::Style );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&LineMarkerMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject LineMarkerMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_LineMarkerMenu.data,
    qt_meta_data_LineMarkerMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void LineMarkerMenu::whichTrigger(unsigned int _t1, QwtSymbol::Style _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_MarkerAlphaMenu_t {
    QByteArrayData data[9];
    char stringdata0[76];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_MarkerAlphaMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_MarkerAlphaMenu_t qt_meta_stringdata_MarkerAlphaMenu = {
    {
QT_MOC_LITERAL(0, 0, 15), // "MarkerAlphaMenu"
QT_MOC_LITERAL(1, 16, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 5), // "which"
QT_MOC_LITERAL(4, 36, 7), // "getNone"
QT_MOC_LITERAL(5, 44, 6), // "getLow"
QT_MOC_LITERAL(6, 51, 9), // "getMedium"
QT_MOC_LITERAL(7, 61, 7), // "getHigh"
QT_MOC_LITERAL(8, 69, 6) // "getOff"

    },
    "MarkerAlphaMenu\0whichTrigger\0\0which\0"
    "getNone\0getLow\0getMedium\0getHigh\0"
    "getOff"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_MarkerAlphaMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       4,    0,   49,    2, 0x0a /* Public */,
       5,    0,   50,    2, 0x0a /* Public */,
       6,    0,   51,    2, 0x0a /* Public */,
       7,    0,   52,    2, 0x0a /* Public */,
       8,    0,   53,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::UInt,    3,    2,

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

       0        // eod
};

void MarkerAlphaMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<MarkerAlphaMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< uint(*)>(_a[2]))); break;
        case 1: _t->getNone(); break;
        case 2: _t->getLow(); break;
        case 3: _t->getMedium(); break;
        case 4: _t->getHigh(); break;
        case 5: _t->getOff(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (MarkerAlphaMenu::*)(unsigned int , unsigned int );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&MarkerAlphaMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject MarkerAlphaMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_MarkerAlphaMenu.data,
    qt_meta_data_MarkerAlphaMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void MarkerAlphaMenu::whichTrigger(unsigned int _t1, unsigned int _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_LineTitleAction_t {
    QByteArrayData data[7];
    char stringdata0[61];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LineTitleAction_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LineTitleAction_t qt_meta_stringdata_LineTitleAction = {
    {
QT_MOC_LITERAL(0, 0, 15), // "LineTitleAction"
QT_MOC_LITERAL(1, 16, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 5), // "which"
QT_MOC_LITERAL(4, 36, 4), // "text"
QT_MOC_LITERAL(5, 41, 11), // "getTextDiag"
QT_MOC_LITERAL(6, 53, 7) // "getText"

    },
    "LineTitleAction\0whichTrigger\0\0which\0"
    "text\0getTextDiag\0getText"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LineTitleAction[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   34,    2, 0x0a /* Public */,
       6,    0,   35,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::QString,    3,    4,

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

       0        // eod
};

void LineTitleAction::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<LineTitleAction *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        case 1: _t->getTextDiag(); break;
        case 2: _t->getText(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (LineTitleAction::*)(unsigned int , const QString & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&LineTitleAction::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject LineTitleAction::staticMetaObject = { {
    QMetaObject::SuperData::link<QAction::staticMetaObject>(),
    qt_meta_stringdata_LineTitleAction.data,
    qt_meta_data_LineTitleAction,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int LineTitleAction::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAction::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 LineTitleAction::whichTrigger(unsigned int _t1, const QString & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_AverageMenu_t {
    QByteArrayData data[10];
    char stringdata0[77];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_AverageMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_AverageMenu_t qt_meta_stringdata_AverageMenu = {
    {
QT_MOC_LITERAL(0, 0, 11), // "AverageMenu"
QT_MOC_LITERAL(1, 12, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 25, 0), // ""
QT_MOC_LITERAL(3, 26, 5), // "alpha"
QT_MOC_LITERAL(4, 32, 6), // "getOff"
QT_MOC_LITERAL(5, 39, 7), // "getHigh"
QT_MOC_LITERAL(6, 47, 9), // "getMedium"
QT_MOC_LITERAL(7, 57, 6), // "getLow"
QT_MOC_LITERAL(8, 64, 8), // "getOther"
QT_MOC_LITERAL(9, 73, 3) // "str"

    },
    "AverageMenu\0whichTrigger\0\0alpha\0getOff\0"
    "getHigh\0getMedium\0getLow\0getOther\0str"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_AverageMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       4,    0,   47,    2, 0x0a /* Public */,
       5,    0,   48,    2, 0x0a /* Public */,
       6,    0,   49,    2, 0x0a /* Public */,
       7,    0,   50,    2, 0x0a /* Public */,
       8,    1,   51,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::Float,    3,

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

       0        // eod
};

void AverageMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<AverageMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< float(*)>(_a[1]))); break;
        case 1: _t->getOff(); break;
        case 2: _t->getHigh(); break;
        case 3: _t->getMedium(); break;
        case 4: _t->getLow(); break;
        case 5: _t->getOther((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (AverageMenu::*)(float );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&AverageMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject AverageMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_AverageMenu.data,
    qt_meta_data_AverageMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void AverageMenu::whichTrigger(float _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_FFTWindowMenu_t {
    QByteArrayData data[13];
    char stringdata0[152];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_FFTWindowMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_FFTWindowMenu_t qt_meta_stringdata_FFTWindowMenu = {
    {
QT_MOC_LITERAL(0, 0, 13), // "FFTWindowMenu"
QT_MOC_LITERAL(1, 14, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 27, 0), // ""
QT_MOC_LITERAL(3, 28, 25), // "gr::fft::window::win_type"
QT_MOC_LITERAL(4, 54, 4), // "type"
QT_MOC_LITERAL(5, 59, 7), // "getNone"
QT_MOC_LITERAL(6, 67, 10), // "getHamming"
QT_MOC_LITERAL(7, 78, 7), // "getHann"
QT_MOC_LITERAL(8, 86, 11), // "getBlackman"
QT_MOC_LITERAL(9, 98, 17), // "getBlackmanharris"
QT_MOC_LITERAL(10, 116, 14), // "getRectangular"
QT_MOC_LITERAL(11, 131, 9), // "getKaiser"
QT_MOC_LITERAL(12, 141, 10) // "getFlattop"

    },
    "FFTWindowMenu\0whichTrigger\0\0"
    "gr::fft::window::win_type\0type\0getNone\0"
    "getHamming\0getHann\0getBlackman\0"
    "getBlackmanharris\0getRectangular\0"
    "getKaiser\0getFlattop"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_FFTWindowMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   62,    2, 0x0a /* Public */,
       6,    0,   63,    2, 0x0a /* Public */,
       7,    0,   64,    2, 0x0a /* Public */,
       8,    0,   65,    2, 0x0a /* Public */,
       9,    0,   66,    2, 0x0a /* Public */,
      10,    0,   67,    2, 0x0a /* Public */,
      11,    0,   68,    2, 0x0a /* Public */,
      12,    0,   69,    2, 0x0a /* Public */,

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

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

       0        // eod
};

void FFTWindowMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<FFTWindowMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< const gr::fft::window::win_type(*)>(_a[1]))); break;
        case 1: _t->getNone(); break;
        case 2: _t->getHamming(); break;
        case 3: _t->getHann(); break;
        case 4: _t->getBlackman(); break;
        case 5: _t->getBlackmanharris(); break;
        case 6: _t->getRectangular(); break;
        case 7: _t->getKaiser(); break;
        case 8: _t->getFlattop(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (FFTWindowMenu::*)(const gr::fft::window::win_type );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&FFTWindowMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject FFTWindowMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_FFTWindowMenu.data,
    qt_meta_data_FFTWindowMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int FFTWindowMenu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMenu::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;
}

// SIGNAL 0
void FFTWindowMenu::whichTrigger(const gr::fft::window::win_type _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_NPointsMenu_t {
    QByteArrayData data[7];
    char stringdata0[63];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_NPointsMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_NPointsMenu_t qt_meta_stringdata_NPointsMenu = {
    {
QT_MOC_LITERAL(0, 0, 11), // "NPointsMenu"
QT_MOC_LITERAL(1, 12, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 25, 0), // ""
QT_MOC_LITERAL(3, 26, 4), // "npts"
QT_MOC_LITERAL(4, 31, 11), // "setDiagText"
QT_MOC_LITERAL(5, 43, 11), // "getTextDiag"
QT_MOC_LITERAL(6, 55, 7) // "getText"

    },
    "NPointsMenu\0whichTrigger\0\0npts\0"
    "setDiagText\0getTextDiag\0getText"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_NPointsMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       4,    1,   37,    2, 0x0a /* Public */,
       5,    0,   40,    2, 0x0a /* Public */,
       6,    0,   41,    2, 0x08 /* Private */,

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

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject NPointsMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QAction::staticMetaObject>(),
    qt_meta_stringdata_NPointsMenu.data,
    qt_meta_data_NPointsMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int NPointsMenu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAction::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;
}

// SIGNAL 0
void NPointsMenu::whichTrigger(const int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_ColorMapMenu_t {
    QByteArrayData data[14];
    char stringdata0[139];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_ColorMapMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ColorMapMenu_t qt_meta_stringdata_ColorMapMenu = {
    {
QT_MOC_LITERAL(0, 0, 12), // "ColorMapMenu"
QT_MOC_LITERAL(1, 13, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 5), // "which"
QT_MOC_LITERAL(4, 33, 4), // "type"
QT_MOC_LITERAL(5, 38, 9), // "min_color"
QT_MOC_LITERAL(6, 48, 9), // "max_color"
QT_MOC_LITERAL(7, 58, 13), // "getMultiColor"
QT_MOC_LITERAL(8, 72, 11), // "getWhiteHot"
QT_MOC_LITERAL(9, 84, 11), // "getBlackHot"
QT_MOC_LITERAL(10, 96, 15), // "getIncandescent"
QT_MOC_LITERAL(11, 112, 9), // "getSunset"
QT_MOC_LITERAL(12, 122, 7), // "getCool"
QT_MOC_LITERAL(13, 130, 8) // "getOther"

    },
    "ColorMapMenu\0whichTrigger\0\0which\0type\0"
    "min_color\0max_color\0getMultiColor\0"
    "getWhiteHot\0getBlackHot\0getIncandescent\0"
    "getSunset\0getCool\0getOther"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ColorMapMenu[] = {

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

 // signals: name, argc, parameters, tag, flags
       1,    4,   64,    2, 0x06 /* Public */,
       1,    3,   73,    2, 0x26 /* Public | MethodCloned */,
       1,    2,   80,    2, 0x26 /* Public | MethodCloned */,

 // slots: name, argc, parameters, tag, flags
       7,    0,   85,    2, 0x0a /* Public */,
       8,    0,   86,    2, 0x0a /* Public */,
       9,    0,   87,    2, 0x0a /* Public */,
      10,    0,   88,    2, 0x0a /* Public */,
      11,    0,   89,    2, 0x0a /* Public */,
      12,    0,   90,    2, 0x0a /* Public */,
      13,    0,   91,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::Int, QMetaType::QColor, QMetaType::QColor,    3,    4,    5,    6,
    QMetaType::Void, QMetaType::UInt, QMetaType::Int, QMetaType::QColor,    3,    4,    5,
    QMetaType::Void, QMetaType::UInt, QMetaType::Int,    3,    4,

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

       0        // eod
};

void ColorMapMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<ColorMapMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const int(*)>(_a[2])),(*reinterpret_cast< const QColor(*)>(_a[3])),(*reinterpret_cast< const QColor(*)>(_a[4]))); break;
        case 1: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const int(*)>(_a[2])),(*reinterpret_cast< const QColor(*)>(_a[3]))); break;
        case 2: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const int(*)>(_a[2]))); break;
        case 3: _t->getMultiColor(); break;
        case 4: _t->getWhiteHot(); break;
        case 5: _t->getBlackHot(); break;
        case 6: _t->getIncandescent(); break;
        case 7: _t->getSunset(); break;
        case 8: _t->getCool(); break;
        case 9: _t->getOther(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (ColorMapMenu::*)(unsigned int , const int , const QColor & , const QColor & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&ColorMapMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject ColorMapMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_ColorMapMenu.data,
    qt_meta_data_ColorMapMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void ColorMapMenu::whichTrigger(unsigned int _t1, const int _t2, const QColor & _t3, const QColor & _t4)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t4))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_TriggerModeMenu_t {
    QByteArrayData data[9];
    char stringdata0[90];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TriggerModeMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TriggerModeMenu_t qt_meta_stringdata_TriggerModeMenu = {
    {
QT_MOC_LITERAL(0, 0, 15), // "TriggerModeMenu"
QT_MOC_LITERAL(1, 16, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 23), // "gr::qtgui::trigger_mode"
QT_MOC_LITERAL(4, 54, 4), // "mode"
QT_MOC_LITERAL(5, 59, 7), // "getFree"
QT_MOC_LITERAL(6, 67, 7), // "getAuto"
QT_MOC_LITERAL(7, 75, 7), // "getNorm"
QT_MOC_LITERAL(8, 83, 6) // "getTag"

    },
    "TriggerModeMenu\0whichTrigger\0\0"
    "gr::qtgui::trigger_mode\0mode\0getFree\0"
    "getAuto\0getNorm\0getTag"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TriggerModeMenu[] = {

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   42,    2, 0x0a /* Public */,
       6,    0,   43,    2, 0x0a /* Public */,
       7,    0,   44,    2, 0x0a /* Public */,
       8,    0,   45,    2, 0x0a /* Public */,

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

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

       0        // eod
};

void TriggerModeMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<TriggerModeMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< gr::qtgui::trigger_mode(*)>(_a[1]))); break;
        case 1: _t->getFree(); break;
        case 2: _t->getAuto(); break;
        case 3: _t->getNorm(); break;
        case 4: _t->getTag(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (TriggerModeMenu::*)(gr::qtgui::trigger_mode );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&TriggerModeMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject TriggerModeMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_TriggerModeMenu.data,
    qt_meta_data_TriggerModeMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int TriggerModeMenu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMenu::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 TriggerModeMenu::whichTrigger(gr::qtgui::trigger_mode _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_TriggerSlopeMenu_t {
    QByteArrayData data[7];
    char stringdata0[76];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TriggerSlopeMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TriggerSlopeMenu_t qt_meta_stringdata_TriggerSlopeMenu = {
    {
QT_MOC_LITERAL(0, 0, 16), // "TriggerSlopeMenu"
QT_MOC_LITERAL(1, 17, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 30, 0), // ""
QT_MOC_LITERAL(3, 31, 24), // "gr::qtgui::trigger_slope"
QT_MOC_LITERAL(4, 56, 5), // "slope"
QT_MOC_LITERAL(5, 62, 6), // "getPos"
QT_MOC_LITERAL(6, 69, 6) // "getNeg"

    },
    "TriggerSlopeMenu\0whichTrigger\0\0"
    "gr::qtgui::trigger_slope\0slope\0getPos\0"
    "getNeg"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TriggerSlopeMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   32,    2, 0x0a /* Public */,
       6,    0,   33,    2, 0x0a /* Public */,

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

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject TriggerSlopeMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_TriggerSlopeMenu.data,
    qt_meta_data_TriggerSlopeMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int TriggerSlopeMenu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMenu::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 TriggerSlopeMenu::whichTrigger(gr::qtgui::trigger_slope _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_TriggerChannelMenu_t {
    QByteArrayData data[5];
    char stringdata0[46];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_TriggerChannelMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_TriggerChannelMenu_t qt_meta_stringdata_TriggerChannelMenu = {
    {
QT_MOC_LITERAL(0, 0, 18), // "TriggerChannelMenu"
QT_MOC_LITERAL(1, 19, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 32, 0), // ""
QT_MOC_LITERAL(3, 33, 1), // "n"
QT_MOC_LITERAL(4, 35, 10) // "getChannel"

    },
    "TriggerChannelMenu\0whichTrigger\0\0n\0"
    "getChannel"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_TriggerChannelMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       4,    0,   27,    2, 0x0a /* Public */,

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

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject TriggerChannelMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_TriggerChannelMenu.data,
    qt_meta_data_TriggerChannelMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void TriggerChannelMenu::whichTrigger(int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_NumberLayoutMenu_t {
    QByteArrayData data[8];
    char stringdata0[82];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_NumberLayoutMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_NumberLayoutMenu_t qt_meta_stringdata_NumberLayoutMenu = {
    {
QT_MOC_LITERAL(0, 0, 16), // "NumberLayoutMenu"
QT_MOC_LITERAL(1, 17, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 30, 0), // ""
QT_MOC_LITERAL(3, 31, 18), // "gr::qtgui::graph_t"
QT_MOC_LITERAL(4, 50, 6), // "layout"
QT_MOC_LITERAL(5, 57, 8), // "getHoriz"
QT_MOC_LITERAL(6, 66, 7), // "getVert"
QT_MOC_LITERAL(7, 74, 7) // "getNone"

    },
    "NumberLayoutMenu\0whichTrigger\0\0"
    "gr::qtgui::graph_t\0layout\0getHoriz\0"
    "getVert\0getNone"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_NumberLayoutMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   37,    2, 0x0a /* Public */,
       6,    0,   38,    2, 0x0a /* Public */,
       7,    0,   39,    2, 0x0a /* Public */,

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

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

       0        // eod
};

void NumberLayoutMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<NumberLayoutMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< gr::qtgui::graph_t(*)>(_a[1]))); break;
        case 1: _t->getHoriz(); break;
        case 2: _t->getVert(); break;
        case 3: _t->getNone(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (NumberLayoutMenu::*)(gr::qtgui::graph_t );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&NumberLayoutMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject NumberLayoutMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_NumberLayoutMenu.data,
    qt_meta_data_NumberLayoutMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int NumberLayoutMenu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMenu::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;
}

// SIGNAL 0
void NumberLayoutMenu::whichTrigger(gr::qtgui::graph_t _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_NumberColorMapMenu_t {
    QByteArrayData data[12];
    char stringdata0[124];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_NumberColorMapMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_NumberColorMapMenu_t qt_meta_stringdata_NumberColorMapMenu = {
    {
QT_MOC_LITERAL(0, 0, 18), // "NumberColorMapMenu"
QT_MOC_LITERAL(1, 19, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 32, 0), // ""
QT_MOC_LITERAL(3, 33, 5), // "which"
QT_MOC_LITERAL(4, 39, 9), // "min_color"
QT_MOC_LITERAL(5, 49, 9), // "max_color"
QT_MOC_LITERAL(6, 59, 8), // "getBlack"
QT_MOC_LITERAL(7, 68, 10), // "getBlueRed"
QT_MOC_LITERAL(8, 79, 11), // "getWhiteHot"
QT_MOC_LITERAL(9, 91, 11), // "getBlackHot"
QT_MOC_LITERAL(10, 103, 11), // "getBlackRed"
QT_MOC_LITERAL(11, 115, 8) // "getOther"

    },
    "NumberColorMapMenu\0whichTrigger\0\0which\0"
    "min_color\0max_color\0getBlack\0getBlueRed\0"
    "getWhiteHot\0getBlackHot\0getBlackRed\0"
    "getOther"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_NumberColorMapMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       6,    0,   56,    2, 0x0a /* Public */,
       7,    0,   57,    2, 0x0a /* Public */,
       8,    0,   58,    2, 0x0a /* Public */,
       9,    0,   59,    2, 0x0a /* Public */,
      10,    0,   60,    2, 0x0a /* Public */,
      11,    0,   61,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::QColor, QMetaType::QColor,    3,    4,    5,

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

       0        // eod
};

void NumberColorMapMenu::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<NumberColorMapMenu *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->whichTrigger((*reinterpret_cast< uint(*)>(_a[1])),(*reinterpret_cast< const QColor(*)>(_a[2])),(*reinterpret_cast< const QColor(*)>(_a[3]))); break;
        case 1: _t->getBlack(); break;
        case 2: _t->getBlueRed(); break;
        case 3: _t->getWhiteHot(); break;
        case 4: _t->getBlackHot(); break;
        case 5: _t->getBlackRed(); break;
        case 6: _t->getOther(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (NumberColorMapMenu::*)(unsigned int , const QColor & , const QColor & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&NumberColorMapMenu::whichTrigger)) {
                *result = 0;
                return;
            }
        }
    }
}

QT_INIT_METAOBJECT const QMetaObject NumberColorMapMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QMenu::staticMetaObject>(),
    qt_meta_stringdata_NumberColorMapMenu.data,
    qt_meta_data_NumberColorMapMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

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

// SIGNAL 0
void NumberColorMapMenu::whichTrigger(unsigned int _t1, const QColor & _t2, const QColor & _t3)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_PopupMenu_t {
    QByteArrayData data[6];
    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_PopupMenu_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_PopupMenu_t qt_meta_stringdata_PopupMenu = {
    {
QT_MOC_LITERAL(0, 0, 9), // "PopupMenu"
QT_MOC_LITERAL(1, 10, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 23, 0), // ""
QT_MOC_LITERAL(3, 24, 4), // "data"
QT_MOC_LITERAL(4, 29, 11), // "getTextDiag"
QT_MOC_LITERAL(5, 41, 7) // "getText"

    },
    "PopupMenu\0whichTrigger\0\0data\0getTextDiag\0"
    "getText"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_PopupMenu[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       4,    0,   32,    2, 0x0a /* Public */,
       5,    0,   33,    2, 0x08 /* Private */,

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

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject PopupMenu::staticMetaObject = { {
    QMetaObject::SuperData::link<QAction::staticMetaObject>(),
    qt_meta_stringdata_PopupMenu.data,
    qt_meta_data_PopupMenu,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int PopupMenu::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAction::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 PopupMenu::whichTrigger(const QString _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_ItemFloatAct_t {
    QByteArrayData data[7];
    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_ItemFloatAct_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_ItemFloatAct_t qt_meta_stringdata_ItemFloatAct = {
    {
QT_MOC_LITERAL(0, 0, 12), // "ItemFloatAct"
QT_MOC_LITERAL(1, 13, 12), // "whichTrigger"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 5), // "which"
QT_MOC_LITERAL(4, 33, 4), // "data"
QT_MOC_LITERAL(5, 38, 11), // "getTextDiag"
QT_MOC_LITERAL(6, 50, 7) // "getText"

    },
    "ItemFloatAct\0whichTrigger\0\0which\0data\0"
    "getTextDiag\0getText"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_ItemFloatAct[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   34,    2, 0x0a /* Public */,
       6,    0,   35,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void, QMetaType::UInt, QMetaType::Float,    3,    4,

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

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject ItemFloatAct::staticMetaObject = { {
    QMetaObject::SuperData::link<QAction::staticMetaObject>(),
    qt_meta_stringdata_ItemFloatAct.data,
    qt_meta_data_ItemFloatAct,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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

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

int ItemFloatAct::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAction::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 ItemFloatAct::whichTrigger(unsigned int _t1, float _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
