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

#include "../../src/ktexteditor-5.39.0/src/dialogs/katedialogs.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'katedialogs.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.9.2. 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_KateGotoBar_t {
    QByteArrayData data[3];
    char stringdata0[22];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateGotoBar_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateGotoBar_t qt_meta_stringdata_KateGotoBar = {
    {
QT_MOC_LITERAL(0, 0, 11), // "KateGotoBar"
QT_MOC_LITERAL(1, 12, 8), // "gotoLine"
QT_MOC_LITERAL(2, 21, 0) // ""

    },
    "KateGotoBar\0gotoLine\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateGotoBar[] = {

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

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

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

const QMetaObject KateGotoBar::staticMetaObject = {
    { &KateViewBarWidget::staticMetaObject, qt_meta_stringdata_KateGotoBar.data,
      qt_meta_data_KateGotoBar,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateGotoBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateViewBarWidget::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_KateDictionaryBar_t {
    QByteArrayData data[5];
    char stringdata0[59];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateDictionaryBar_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateDictionaryBar_t qt_meta_stringdata_KateDictionaryBar = {
    {
QT_MOC_LITERAL(0, 0, 17), // "KateDictionaryBar"
QT_MOC_LITERAL(1, 18, 10), // "updateData"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 17), // "dictionaryChanged"
QT_MOC_LITERAL(4, 48, 10) // "dictionary"

    },
    "KateDictionaryBar\0updateData\0\0"
    "dictionaryChanged\0dictionary"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateDictionaryBar[] = {

 // 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,    0,   24,    2, 0x0a /* Public */,
       3,    1,   25,    2, 0x09 /* Protected */,

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

       0        // eod
};

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

const QMetaObject KateDictionaryBar::staticMetaObject = {
    { &KateViewBarWidget::staticMetaObject, qt_meta_stringdata_KateDictionaryBar.data,
      qt_meta_data_KateDictionaryBar,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateDictionaryBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateViewBarWidget::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_KateIndentConfigTab_t {
    QByteArrayData data[9];
    char stringdata0[80];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateIndentConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateIndentConfigTab_t qt_meta_stringdata_KateIndentConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 19), // "KateIndentConfigTab"
QT_MOC_LITERAL(1, 20, 5), // "apply"
QT_MOC_LITERAL(2, 26, 0), // ""
QT_MOC_LITERAL(3, 27, 6), // "reload"
QT_MOC_LITERAL(4, 34, 5), // "reset"
QT_MOC_LITERAL(5, 40, 8), // "defaults"
QT_MOC_LITERAL(6, 49, 11), // "slotChanged"
QT_MOC_LITERAL(7, 61, 13), // "showWhatsThis"
QT_MOC_LITERAL(8, 75, 4) // "text"

    },
    "KateIndentConfigTab\0apply\0\0reload\0"
    "reset\0defaults\0slotChanged\0showWhatsThis\0"
    "text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateIndentConfigTab[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   44,    2, 0x0a /* Public */,
       3,    0,   45,    2, 0x0a /* Public */,
       4,    0,   46,    2, 0x0a /* Public */,
       5,    0,   47,    2, 0x0a /* Public */,
       6,    0,   48,    2, 0x08 /* Private */,
       7,    1,   49,    2, 0x08 /* Private */,

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

       0        // eod
};

void KateIndentConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateIndentConfigTab *_t = static_cast<KateIndentConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        case 4: _t->slotChanged(); break;
        case 5: _t->showWhatsThis((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject KateIndentConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateIndentConfigTab.data,
      qt_meta_data_KateIndentConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateIndentConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::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;
}
struct qt_meta_stringdata_KateCompletionConfigTab_t {
    QByteArrayData data[8];
    char stringdata0[72];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateCompletionConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateCompletionConfigTab_t qt_meta_stringdata_KateCompletionConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 23), // "KateCompletionConfigTab"
QT_MOC_LITERAL(1, 24, 5), // "apply"
QT_MOC_LITERAL(2, 30, 0), // ""
QT_MOC_LITERAL(3, 31, 6), // "reload"
QT_MOC_LITERAL(4, 38, 5), // "reset"
QT_MOC_LITERAL(5, 44, 8), // "defaults"
QT_MOC_LITERAL(6, 53, 13), // "showWhatsThis"
QT_MOC_LITERAL(7, 67, 4) // "text"

    },
    "KateCompletionConfigTab\0apply\0\0reload\0"
    "reset\0defaults\0showWhatsThis\0text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateCompletionConfigTab[] = {

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

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

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

       0        // eod
};

void KateCompletionConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateCompletionConfigTab *_t = static_cast<KateCompletionConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        case 4: _t->showWhatsThis((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject KateCompletionConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateCompletionConfigTab.data,
      qt_meta_data_KateCompletionConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateCompletionConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}
struct qt_meta_stringdata_KateEditGeneralConfigTab_t {
    QByteArrayData data[6];
    char stringdata0[54];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateEditGeneralConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateEditGeneralConfigTab_t qt_meta_stringdata_KateEditGeneralConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 24), // "KateEditGeneralConfigTab"
QT_MOC_LITERAL(1, 25, 5), // "apply"
QT_MOC_LITERAL(2, 31, 0), // ""
QT_MOC_LITERAL(3, 32, 6), // "reload"
QT_MOC_LITERAL(4, 39, 5), // "reset"
QT_MOC_LITERAL(5, 45, 8) // "defaults"

    },
    "KateEditGeneralConfigTab\0apply\0\0reload\0"
    "reset\0defaults"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateEditGeneralConfigTab[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   34,    2, 0x0a /* Public */,
       3,    0,   35,    2, 0x0a /* Public */,
       4,    0,   36,    2, 0x0a /* Public */,
       5,    0,   37,    2, 0x0a /* Public */,

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

       0        // eod
};

void KateEditGeneralConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateEditGeneralConfigTab *_t = static_cast<KateEditGeneralConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject KateEditGeneralConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateEditGeneralConfigTab.data,
      qt_meta_data_KateEditGeneralConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateEditGeneralConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
    return _id;
}
struct qt_meta_stringdata_KateNavigationConfigTab_t {
    QByteArrayData data[6];
    char stringdata0[53];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateNavigationConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateNavigationConfigTab_t qt_meta_stringdata_KateNavigationConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 23), // "KateNavigationConfigTab"
QT_MOC_LITERAL(1, 24, 5), // "apply"
QT_MOC_LITERAL(2, 30, 0), // ""
QT_MOC_LITERAL(3, 31, 6), // "reload"
QT_MOC_LITERAL(4, 38, 5), // "reset"
QT_MOC_LITERAL(5, 44, 8) // "defaults"

    },
    "KateNavigationConfigTab\0apply\0\0reload\0"
    "reset\0defaults"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateNavigationConfigTab[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   34,    2, 0x0a /* Public */,
       3,    0,   35,    2, 0x0a /* Public */,
       4,    0,   36,    2, 0x0a /* Public */,
       5,    0,   37,    2, 0x0a /* Public */,

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

       0        // eod
};

void KateNavigationConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateNavigationConfigTab *_t = static_cast<KateNavigationConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject KateNavigationConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateNavigationConfigTab.data,
      qt_meta_data_KateNavigationConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateNavigationConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
    return _id;
}
struct qt_meta_stringdata_KateSpellCheckConfigTab_t {
    QByteArrayData data[8];
    char stringdata0[72];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateSpellCheckConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateSpellCheckConfigTab_t qt_meta_stringdata_KateSpellCheckConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 23), // "KateSpellCheckConfigTab"
QT_MOC_LITERAL(1, 24, 5), // "apply"
QT_MOC_LITERAL(2, 30, 0), // ""
QT_MOC_LITERAL(3, 31, 6), // "reload"
QT_MOC_LITERAL(4, 38, 5), // "reset"
QT_MOC_LITERAL(5, 44, 8), // "defaults"
QT_MOC_LITERAL(6, 53, 13), // "showWhatsThis"
QT_MOC_LITERAL(7, 67, 4) // "text"

    },
    "KateSpellCheckConfigTab\0apply\0\0reload\0"
    "reset\0defaults\0showWhatsThis\0text"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateSpellCheckConfigTab[] = {

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

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

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

       0        // eod
};

void KateSpellCheckConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateSpellCheckConfigTab *_t = static_cast<KateSpellCheckConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        case 4: _t->showWhatsThis((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject KateSpellCheckConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateSpellCheckConfigTab.data,
      qt_meta_data_KateSpellCheckConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateSpellCheckConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}
struct qt_meta_stringdata_KateEditConfigTab_t {
    QByteArrayData data[6];
    char stringdata0[47];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateEditConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateEditConfigTab_t qt_meta_stringdata_KateEditConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 17), // "KateEditConfigTab"
QT_MOC_LITERAL(1, 18, 5), // "apply"
QT_MOC_LITERAL(2, 24, 0), // ""
QT_MOC_LITERAL(3, 25, 6), // "reload"
QT_MOC_LITERAL(4, 32, 5), // "reset"
QT_MOC_LITERAL(5, 38, 8) // "defaults"

    },
    "KateEditConfigTab\0apply\0\0reload\0reset\0"
    "defaults"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateEditConfigTab[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   34,    2, 0x0a /* Public */,
       3,    0,   35,    2, 0x0a /* Public */,
       4,    0,   36,    2, 0x0a /* Public */,
       5,    0,   37,    2, 0x0a /* Public */,

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

       0        // eod
};

void KateEditConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateEditConfigTab *_t = static_cast<KateEditConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject KateEditConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateEditConfigTab.data,
      qt_meta_data_KateEditConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateEditConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
    return _id;
}
struct qt_meta_stringdata_KateViewDefaultsConfig_t {
    QByteArrayData data[6];
    char stringdata0[52];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateViewDefaultsConfig_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateViewDefaultsConfig_t qt_meta_stringdata_KateViewDefaultsConfig = {
    {
QT_MOC_LITERAL(0, 0, 22), // "KateViewDefaultsConfig"
QT_MOC_LITERAL(1, 23, 5), // "apply"
QT_MOC_LITERAL(2, 29, 0), // ""
QT_MOC_LITERAL(3, 30, 6), // "reload"
QT_MOC_LITERAL(4, 37, 5), // "reset"
QT_MOC_LITERAL(5, 43, 8) // "defaults"

    },
    "KateViewDefaultsConfig\0apply\0\0reload\0"
    "reset\0defaults"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateViewDefaultsConfig[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   34,    2, 0x0a /* Public */,
       3,    0,   35,    2, 0x0a /* Public */,
       4,    0,   36,    2, 0x0a /* Public */,
       5,    0,   37,    2, 0x0a /* Public */,

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

       0        // eod
};

void KateViewDefaultsConfig::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateViewDefaultsConfig *_t = static_cast<KateViewDefaultsConfig *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject KateViewDefaultsConfig::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateViewDefaultsConfig.data,
      qt_meta_data_KateViewDefaultsConfig,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateViewDefaultsConfig::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
    return _id;
}
struct qt_meta_stringdata_KateSaveConfigTab_t {
    QByteArrayData data[7];
    char stringdata0[67];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateSaveConfigTab_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateSaveConfigTab_t qt_meta_stringdata_KateSaveConfigTab = {
    {
QT_MOC_LITERAL(0, 0, 17), // "KateSaveConfigTab"
QT_MOC_LITERAL(1, 18, 5), // "apply"
QT_MOC_LITERAL(2, 24, 0), // ""
QT_MOC_LITERAL(3, 25, 6), // "reload"
QT_MOC_LITERAL(4, 32, 5), // "reset"
QT_MOC_LITERAL(5, 38, 8), // "defaults"
QT_MOC_LITERAL(6, 47, 19) // "swapFileModeChanged"

    },
    "KateSaveConfigTab\0apply\0\0reload\0reset\0"
    "defaults\0swapFileModeChanged"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateSaveConfigTab[] = {

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

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

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

       0        // eod
};

void KateSaveConfigTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateSaveConfigTab *_t = static_cast<KateSaveConfigTab *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->apply(); break;
        case 1: _t->reload(); break;
        case 2: _t->reset(); break;
        case 3: _t->defaults(); break;
        case 4: _t->swapFileModeChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject KateSaveConfigTab::staticMetaObject = {
    { &KateConfigPage::staticMetaObject, qt_meta_stringdata_KateSaveConfigTab.data,
      qt_meta_data_KateSaveConfigTab,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateSaveConfigTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = KateConfigPage::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
    return _id;
}
struct qt_meta_stringdata_KateHlDownloadDialog_t {
    QByteArrayData data[6];
    char stringdata0[66];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateHlDownloadDialog_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateHlDownloadDialog_t qt_meta_stringdata_KateHlDownloadDialog = {
    {
QT_MOC_LITERAL(0, 0, 20), // "KateHlDownloadDialog"
QT_MOC_LITERAL(1, 21, 16), // "listDataReceived"
QT_MOC_LITERAL(2, 38, 0), // ""
QT_MOC_LITERAL(3, 39, 9), // "KIO::Job*"
QT_MOC_LITERAL(4, 49, 4), // "data"
QT_MOC_LITERAL(5, 54, 11) // "slotInstall"

    },
    "KateHlDownloadDialog\0listDataReceived\0"
    "\0KIO::Job*\0data\0slotInstall"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateHlDownloadDialog[] = {

 // 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,    2,   24,    2, 0x08 /* Private */,
       5,    0,   29,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void, 0x80000000 | 3, QMetaType::QByteArray,    2,    4,
    QMetaType::Void,

       0        // eod
};

void KateHlDownloadDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateHlDownloadDialog *_t = static_cast<KateHlDownloadDialog *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->listDataReceived((*reinterpret_cast< KIO::Job*(*)>(_a[1])),(*reinterpret_cast< const QByteArray(*)>(_a[2]))); break;
        case 1: _t->slotInstall(); break;
        default: ;
        }
    }
}

const QMetaObject KateHlDownloadDialog::staticMetaObject = {
    { &QDialog::staticMetaObject, qt_meta_stringdata_KateHlDownloadDialog.data,
      qt_meta_data_KateHlDownloadDialog,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateHlDownloadDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::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_KateModOnHdPrompt_t {
    QByteArrayData data[8];
    char stringdata0[104];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_KateModOnHdPrompt_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_KateModOnHdPrompt_t qt_meta_stringdata_KateModOnHdPrompt = {
    {
QT_MOC_LITERAL(0, 0, 17), // "KateModOnHdPrompt"
QT_MOC_LITERAL(1, 18, 15), // "saveAsTriggered"
QT_MOC_LITERAL(2, 34, 0), // ""
QT_MOC_LITERAL(3, 35, 15), // "ignoreTriggered"
QT_MOC_LITERAL(4, 51, 15), // "reloadTriggered"
QT_MOC_LITERAL(5, 67, 8), // "slotDiff"
QT_MOC_LITERAL(6, 76, 17), // "slotDataAvailable"
QT_MOC_LITERAL(7, 94, 9) // "slotPDone"

    },
    "KateModOnHdPrompt\0saveAsTriggered\0\0"
    "ignoreTriggered\0reloadTriggered\0"
    "slotDiff\0slotDataAvailable\0slotPDone"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_KateModOnHdPrompt[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       5,    0,   47,    2, 0x08 /* Private */,
       6,    0,   48,    2, 0x08 /* Private */,
       7,    0,   49,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,

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

       0        // eod
};

void KateModOnHdPrompt::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        KateModOnHdPrompt *_t = static_cast<KateModOnHdPrompt *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->saveAsTriggered(); break;
        case 1: _t->ignoreTriggered(); break;
        case 2: _t->reloadTriggered(); break;
        case 3: _t->slotDiff(); break;
        case 4: _t->slotDataAvailable(); break;
        case 5: _t->slotPDone(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (KateModOnHdPrompt::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KateModOnHdPrompt::saveAsTriggered)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (KateModOnHdPrompt::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KateModOnHdPrompt::ignoreTriggered)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (KateModOnHdPrompt::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&KateModOnHdPrompt::reloadTriggered)) {
                *result = 2;
                return;
            }
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject KateModOnHdPrompt::staticMetaObject = {
    { &QObject::staticMetaObject, qt_meta_stringdata_KateModOnHdPrompt.data,
      qt_meta_data_KateModOnHdPrompt,  qt_static_metacall, nullptr, nullptr}
};


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

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

int KateModOnHdPrompt::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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 KateModOnHdPrompt::saveAsTriggered()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void KateModOnHdPrompt::ignoreTriggered()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void KateModOnHdPrompt::reloadTriggered()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
