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

#include "../../../../src/lyx-2.4.4/src/frontends/qt/GuiPrefs.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'GuiPrefs.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.9.4. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_lyx__frontend__GuiPreferences_t {
    QByteArrayData data[7];
    char stringdata0[85];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__GuiPreferences_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__GuiPreferences_t qt_meta_stringdata_lyx__frontend__GuiPreferences = {
    {
QT_MOC_LITERAL(0, 0, 29), // "lyx::frontend::GuiPreferences"
QT_MOC_LITERAL(1, 30, 12), // "prefsApplied"
QT_MOC_LITERAL(2, 43, 0), // ""
QT_MOC_LITERAL(3, 44, 5), // "LyXRC"
QT_MOC_LITERAL(4, 50, 2), // "rc"
QT_MOC_LITERAL(5, 53, 14), // "change_adaptor"
QT_MOC_LITERAL(6, 68, 16) // "slotFileSelected"

    },
    "lyx::frontend::GuiPreferences\0"
    "prefsApplied\0\0LyXRC\0rc\0change_adaptor\0"
    "slotFileSelected"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__GuiPreferences[] = {

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

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

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

       0        // eod
};

void lyx::frontend::GuiPreferences::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        GuiPreferences *_t = static_cast<GuiPreferences *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->prefsApplied((*reinterpret_cast< const LyXRC(*)>(_a[1]))); break;
        case 1: _t->change_adaptor(); break;
        case 2: _t->slotFileSelected((*reinterpret_cast< QString(*)>(_a[1]))); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            typedef void (GuiPreferences::*_t)(LyXRC const & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&GuiPreferences::prefsApplied)) {
                *result = 0;
                return;
            }
        }
    }
}

const QMetaObject lyx::frontend::GuiPreferences::staticMetaObject = {
    { &GuiDialog::staticMetaObject, qt_meta_stringdata_lyx__frontend__GuiPreferences.data,
      qt_meta_data_lyx__frontend__GuiPreferences,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::GuiPreferences::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__GuiPreferences.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefsUi"))
        return static_cast< Ui::PrefsUi*>(this);
    return GuiDialog::qt_metacast(_clname);
}

int lyx::frontend::GuiPreferences::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = GuiDialog::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 lyx::frontend::GuiPreferences::prefsApplied(LyXRC const & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_lyx__frontend__PrefModule_t {
    QByteArrayData data[3];
    char stringdata0[35];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefModule_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefModule_t qt_meta_stringdata_lyx__frontend__PrefModule = {
    {
QT_MOC_LITERAL(0, 0, 25), // "lyx::frontend::PrefModule"
QT_MOC_LITERAL(1, 26, 7), // "changed"
QT_MOC_LITERAL(2, 34, 0) // ""

    },
    "lyx::frontend::PrefModule\0changed\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefModule[] = {

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

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

 // signals: parameters
    QMetaType::Void,

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefModule::staticMetaObject = {
    { &QWidget::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefModule.data,
      qt_meta_data_lyx__frontend__PrefModule,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefModule::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefModule.stringdata0))
        return static_cast<void*>(this);
    return QWidget::qt_metacast(_clname);
}

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

// SIGNAL 0
void lyx::frontend::PrefModule::changed()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_lyx__frontend__PrefOutput_t {
    QByteArrayData data[1];
    char stringdata0[26];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefOutput_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefOutput_t qt_meta_stringdata_lyx__frontend__PrefOutput = {
    {
QT_MOC_LITERAL(0, 0, 25) // "lyx::frontend::PrefOutput"

    },
    "lyx::frontend::PrefOutput"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefOutput[] = {

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

       0        // eod
};

void lyx::frontend::PrefOutput::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject lyx::frontend::PrefOutput::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefOutput.data,
      qt_meta_data_lyx__frontend__PrefOutput,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefOutput::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefOutput.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefOutputUi"))
        return static_cast< Ui::PrefOutputUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefOutput::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::qt_metacall(_c, _id, _a);
    return _id;
}
struct qt_meta_stringdata_lyx__frontend__PrefInput_t {
    QByteArrayData data[6];
    char stringdata0[127];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefInput_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefInput_t qt_meta_stringdata_lyx__frontend__PrefInput = {
    {
QT_MOC_LITERAL(0, 0, 24), // "lyx::frontend::PrefInput"
QT_MOC_LITERAL(1, 25, 24), // "on_firstKeymapPB_clicked"
QT_MOC_LITERAL(2, 50, 0), // ""
QT_MOC_LITERAL(3, 51, 25), // "on_secondKeymapPB_clicked"
QT_MOC_LITERAL(4, 77, 19), // "on_keymapCB_toggled"
QT_MOC_LITERAL(5, 97, 29) // "on_scrollzoomEnableCB_toggled"

    },
    "lyx::frontend::PrefInput\0"
    "on_firstKeymapPB_clicked\0\0"
    "on_secondKeymapPB_clicked\0on_keymapCB_toggled\0"
    "on_scrollzoomEnableCB_toggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefInput[] = {

 // 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,    1,   34,    2, 0x08 /* Private */,
       3,    1,   37,    2, 0x08 /* Private */,
       4,    1,   40,    2, 0x08 /* Private */,
       5,    1,   43,    2, 0x08 /* Private */,

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

       0        // eod
};

void lyx::frontend::PrefInput::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefInput *_t = static_cast<PrefInput *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->on_firstKeymapPB_clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 1: _t->on_secondKeymapPB_clicked((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 2: _t->on_keymapCB_toggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 3: _t->on_scrollzoomEnableCB_toggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject lyx::frontend::PrefInput::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefInput.data,
      qt_meta_data_lyx__frontend__PrefInput,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefInput::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefInput.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefInputUi"))
        return static_cast< Ui::PrefInputUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefInput::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefCompletion_t {
    QByteArrayData data[4];
    char stringdata0[78];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefCompletion_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefCompletion_t qt_meta_stringdata_lyx__frontend__PrefCompletion = {
    {
QT_MOC_LITERAL(0, 0, 29), // "lyx::frontend::PrefCompletion"
QT_MOC_LITERAL(1, 30, 22), // "on_popupTextCB_clicked"
QT_MOC_LITERAL(2, 53, 0), // ""
QT_MOC_LITERAL(3, 54, 23) // "on_inlineTextCB_clicked"

    },
    "lyx::frontend::PrefCompletion\0"
    "on_popupTextCB_clicked\0\0on_inlineTextCB_clicked"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefCompletion[] = {

 // 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, 0x08 /* Private */,
       3,    0,   25,    2, 0x08 /* Private */,

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

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefCompletion::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefCompletion.data,
      qt_meta_data_lyx__frontend__PrefCompletion,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefCompletion::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefCompletion.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefCompletionUi"))
        return static_cast< Ui::PrefCompletionUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefCompletion::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefLatex_t {
    QByteArrayData data[6];
    char stringdata0[109];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefLatex_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefLatex_t qt_meta_stringdata_lyx__frontend__PrefLatex = {
    {
QT_MOC_LITERAL(0, 0, 24), // "lyx::frontend::PrefLatex"
QT_MOC_LITERAL(1, 25, 26), // "on_latexBibtexCO_activated"
QT_MOC_LITERAL(2, 52, 0), // ""
QT_MOC_LITERAL(3, 53, 1), // "n"
QT_MOC_LITERAL(4, 55, 27), // "on_latexJBibtexCO_activated"
QT_MOC_LITERAL(5, 83, 25) // "on_latexIndexCO_activated"

    },
    "lyx::frontend::PrefLatex\0"
    "on_latexBibtexCO_activated\0\0n\0"
    "on_latexJBibtexCO_activated\0"
    "on_latexIndexCO_activated"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefLatex[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    1,   29,    2, 0x08 /* Private */,
       4,    1,   32,    2, 0x08 /* Private */,
       5,    1,   35,    2, 0x08 /* Private */,

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

       0        // eod
};

void lyx::frontend::PrefLatex::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefLatex *_t = static_cast<PrefLatex *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->on_latexBibtexCO_activated((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 1: _t->on_latexJBibtexCO_activated((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 2: _t->on_latexIndexCO_activated((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject lyx::frontend::PrefLatex::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefLatex.data,
      qt_meta_data_lyx__frontend__PrefLatex,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefLatex::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefLatex.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefLatexUi"))
        return static_cast< Ui::PrefLatexUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefLatex::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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;
}
struct qt_meta_stringdata_lyx__frontend__PrefScreenFonts_t {
    QByteArrayData data[9];
    char stringdata0[122];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefScreenFonts_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefScreenFonts_t qt_meta_stringdata_lyx__frontend__PrefScreenFonts = {
    {
QT_MOC_LITERAL(0, 0, 30), // "lyx::frontend::PrefScreenFonts"
QT_MOC_LITERAL(1, 31, 11), // "selectRoman"
QT_MOC_LITERAL(2, 43, 0), // ""
QT_MOC_LITERAL(3, 44, 10), // "selectSans"
QT_MOC_LITERAL(4, 55, 16), // "selectTypewriter"
QT_MOC_LITERAL(5, 72, 18), // "screenFontsChanged"
QT_MOC_LITERAL(6, 91, 21), // "updateScreenFontSizes"
QT_MOC_LITERAL(7, 113, 5), // "LyXRC"
QT_MOC_LITERAL(8, 119, 2) // "rc"

    },
    "lyx::frontend::PrefScreenFonts\0"
    "selectRoman\0\0selectSans\0selectTypewriter\0"
    "screenFontsChanged\0updateScreenFontSizes\0"
    "LyXRC\0rc"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefScreenFonts[] = {

 // 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,    1,   39,    2, 0x08 /* Private */,
       3,    1,   42,    2, 0x08 /* Private */,
       4,    1,   45,    2, 0x08 /* Private */,
       5,    0,   48,    2, 0x08 /* Private */,
       6,    1,   49,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 7,    8,

       0        // eod
};

void lyx::frontend::PrefScreenFonts::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefScreenFonts *_t = static_cast<PrefScreenFonts *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->selectRoman((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 1: _t->selectSans((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 2: _t->selectTypewriter((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 3: _t->screenFontsChanged(); break;
        case 4: _t->updateScreenFontSizes((*reinterpret_cast< const LyXRC(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject lyx::frontend::PrefScreenFonts::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefScreenFonts.data,
      qt_meta_data_lyx__frontend__PrefScreenFonts,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefScreenFonts::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefScreenFonts.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefScreenFontsUi"))
        return static_cast< Ui::PrefScreenFontsUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefScreenFonts::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefColors_t {
    QByteArrayData data[14];
    char stringdata0[177];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefColors_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefColors_t qt_meta_stringdata_lyx__frontend__PrefColors = {
    {
QT_MOC_LITERAL(0, 0, 25), // "lyx::frontend::PrefColors"
QT_MOC_LITERAL(1, 26, 11), // "changeColor"
QT_MOC_LITERAL(2, 38, 0), // ""
QT_MOC_LITERAL(3, 39, 10), // "resetColor"
QT_MOC_LITERAL(4, 50, 13), // "resetAllColor"
QT_MOC_LITERAL(5, 64, 14), // "changeSysColor"
QT_MOC_LITERAL(6, 79, 25), // "changeLyxObjectsSelection"
QT_MOC_LITERAL(7, 105, 8), // "setColor"
QT_MOC_LITERAL(8, 114, 3), // "row"
QT_MOC_LITERAL(9, 118, 9), // "new_color"
QT_MOC_LITERAL(10, 128, 9), // "old_color"
QT_MOC_LITERAL(11, 138, 14), // "isDefaultColor"
QT_MOC_LITERAL(12, 153, 5), // "color"
QT_MOC_LITERAL(13, 159, 17) // "setDisabledResets"

    },
    "lyx::frontend::PrefColors\0changeColor\0"
    "\0resetColor\0resetAllColor\0changeSysColor\0"
    "changeLyxObjectsSelection\0setColor\0"
    "row\0new_color\0old_color\0isDefaultColor\0"
    "color\0setDisabledResets"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefColors[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   54,    2, 0x08 /* Private */,
       3,    0,   55,    2, 0x08 /* Private */,
       4,    0,   56,    2, 0x08 /* Private */,
       5,    0,   57,    2, 0x08 /* Private */,
       6,    0,   58,    2, 0x08 /* Private */,
       7,    3,   59,    2, 0x08 /* Private */,
      11,    2,   66,    2, 0x08 /* Private */,
      13,    0,   71,    2, 0x08 /* Private */,

 // slots: parameters
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Bool, QMetaType::Int, QMetaType::QColor, QMetaType::QString,    8,    9,   10,
    QMetaType::Bool, QMetaType::Int, QMetaType::QString,    8,   12,
    QMetaType::Void,

       0        // eod
};

void lyx::frontend::PrefColors::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefColors *_t = static_cast<PrefColors *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->changeColor(); break;
        case 1: _t->resetColor(); break;
        case 2: _t->resetAllColor(); break;
        case 3: _t->changeSysColor(); break;
        case 4: _t->changeLyxObjectsSelection(); break;
        case 5: { bool _r = _t->setColor((*reinterpret_cast< const int(*)>(_a[1])),(*reinterpret_cast< const QColor(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 6: { bool _r = _t->isDefaultColor((*reinterpret_cast< const int(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->setDisabledResets(); break;
        default: ;
        }
    }
}

const QMetaObject lyx::frontend::PrefColors::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefColors.data,
      qt_meta_data_lyx__frontend__PrefColors,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefColors::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefColors.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefColorsUi"))
        return static_cast< Ui::PrefColorsUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefColors::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 8;
    }
    return _id;
}
struct qt_meta_stringdata_lyx__frontend__PrefDisplay_t {
    QByteArrayData data[3];
    char stringdata0[68];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefDisplay_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefDisplay_t qt_meta_stringdata_lyx__frontend__PrefDisplay = {
    {
QT_MOC_LITERAL(0, 0, 26), // "lyx::frontend::PrefDisplay"
QT_MOC_LITERAL(1, 27, 39), // "on_instantPreviewCO_currentIn..."
QT_MOC_LITERAL(2, 67, 0) // ""

    },
    "lyx::frontend::PrefDisplay\0"
    "on_instantPreviewCO_currentIndexChanged\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefDisplay[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x08 /* Private */,

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

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefDisplay::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefDisplay.data,
      qt_meta_data_lyx__frontend__PrefDisplay,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefDisplay::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefDisplay.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefDisplayUi"))
        return static_cast< Ui::PrefDisplayUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefDisplay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefPaths_t {
    QByteArrayData data[10];
    char stringdata0[159];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefPaths_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefPaths_t qt_meta_stringdata_lyx__frontend__PrefPaths = {
    {
QT_MOC_LITERAL(0, 0, 24), // "lyx::frontend::PrefPaths"
QT_MOC_LITERAL(1, 25, 16), // "selectExampledir"
QT_MOC_LITERAL(2, 42, 0), // ""
QT_MOC_LITERAL(3, 43, 17), // "selectTemplatedir"
QT_MOC_LITERAL(4, 61, 13), // "selectTempdir"
QT_MOC_LITERAL(5, 75, 15), // "selectBackupdir"
QT_MOC_LITERAL(6, 91, 16), // "selectWorkingdir"
QT_MOC_LITERAL(7, 108, 18), // "selectThesaurusdir"
QT_MOC_LITERAL(8, 127, 17), // "selectHunspelldir"
QT_MOC_LITERAL(9, 145, 13) // "selectLyxPipe"

    },
    "lyx::frontend::PrefPaths\0selectExampledir\0"
    "\0selectTemplatedir\0selectTempdir\0"
    "selectBackupdir\0selectWorkingdir\0"
    "selectThesaurusdir\0selectHunspelldir\0"
    "selectLyxPipe"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefPaths[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   54,    2, 0x08 /* Private */,
       3,    0,   55,    2, 0x08 /* Private */,
       4,    0,   56,    2, 0x08 /* Private */,
       5,    0,   57,    2, 0x08 /* Private */,
       6,    0,   58,    2, 0x08 /* Private */,
       7,    0,   59,    2, 0x08 /* Private */,
       8,    0,   60,    2, 0x08 /* Private */,
       9,    0,   61,    2, 0x08 /* Private */,

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

       0        // eod
};

void lyx::frontend::PrefPaths::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefPaths *_t = static_cast<PrefPaths *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->selectExampledir(); break;
        case 1: _t->selectTemplatedir(); break;
        case 2: _t->selectTempdir(); break;
        case 3: _t->selectBackupdir(); break;
        case 4: _t->selectWorkingdir(); break;
        case 5: _t->selectThesaurusdir(); break;
        case 6: _t->selectHunspelldir(); break;
        case 7: _t->selectLyxPipe(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject lyx::frontend::PrefPaths::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefPaths.data,
      qt_meta_data_lyx__frontend__PrefPaths,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefPaths::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefPaths.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefPathsUi"))
        return static_cast< Ui::PrefPathsUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefPaths::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 8;
    }
    return _id;
}
struct qt_meta_stringdata_lyx__frontend__PrefSpellchecker_t {
    QByteArrayData data[3];
    char stringdata0[71];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefSpellchecker_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefSpellchecker_t qt_meta_stringdata_lyx__frontend__PrefSpellchecker = {
    {
QT_MOC_LITERAL(0, 0, 31), // "lyx::frontend::PrefSpellchecker"
QT_MOC_LITERAL(1, 32, 37), // "on_spellcheckerCB_currentInde..."
QT_MOC_LITERAL(2, 70, 0) // ""

    },
    "lyx::frontend::PrefSpellchecker\0"
    "on_spellcheckerCB_currentIndexChanged\0"
    ""
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefSpellchecker[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    1,   19,    2, 0x08 /* Private */,

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

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefSpellchecker::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefSpellchecker.data,
      qt_meta_data_lyx__frontend__PrefSpellchecker,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefSpellchecker::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefSpellchecker.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefSpellcheckerUi"))
        return static_cast< Ui::PrefSpellcheckerUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefSpellchecker::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefConverters_t {
    QByteArrayData data[11];
    char stringdata0[188];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefConverters_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefConverters_t qt_meta_stringdata_lyx__frontend__PrefConverters = {
    {
QT_MOC_LITERAL(0, 0, 29), // "lyx::frontend::PrefConverters"
QT_MOC_LITERAL(1, 30, 9), // "updateGui"
QT_MOC_LITERAL(2, 40, 0), // ""
QT_MOC_LITERAL(3, 41, 15), // "updateConverter"
QT_MOC_LITERAL(4, 57, 15), // "switchConverter"
QT_MOC_LITERAL(5, 73, 15), // "removeConverter"
QT_MOC_LITERAL(6, 89, 15), // "changeConverter"
QT_MOC_LITERAL(7, 105, 23), // "on_cacheCB_stateChanged"
QT_MOC_LITERAL(8, 129, 5), // "state"
QT_MOC_LITERAL(9, 135, 30), // "on_needauthForbiddenCB_toggled"
QT_MOC_LITERAL(10, 166, 21) // "on_needauthCB_toggled"

    },
    "lyx::frontend::PrefConverters\0updateGui\0"
    "\0updateConverter\0switchConverter\0"
    "removeConverter\0changeConverter\0"
    "on_cacheCB_stateChanged\0state\0"
    "on_needauthForbiddenCB_toggled\0"
    "on_needauthCB_toggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefConverters[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   54,    2, 0x0a /* Public */,
       3,    0,   55,    2, 0x08 /* Private */,
       4,    0,   56,    2, 0x08 /* Private */,
       5,    0,   57,    2, 0x08 /* Private */,
       6,    0,   58,    2, 0x08 /* Private */,
       7,    1,   59,    2, 0x08 /* Private */,
       9,    1,   62,    2, 0x08 /* Private */,
      10,    1,   65,    2, 0x08 /* Private */,

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

       0        // eod
};

void lyx::frontend::PrefConverters::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefConverters *_t = static_cast<PrefConverters *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->updateGui(); break;
        case 1: _t->updateConverter(); break;
        case 2: _t->switchConverter(); break;
        case 3: _t->removeConverter(); break;
        case 4: _t->changeConverter(); break;
        case 5: _t->on_cacheCB_stateChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 6: _t->on_needauthForbiddenCB_toggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 7: _t->on_needauthCB_toggled((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject lyx::frontend::PrefConverters::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefConverters.data,
      qt_meta_data_lyx__frontend__PrefConverters,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefConverters::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefConverters.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefConvertersUi"))
        return static_cast< Ui::PrefConvertersUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefConverters::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 8;
    }
    return _id;
}
struct qt_meta_stringdata_lyx__frontend__PrefFileformats_t {
    QByteArrayData data[21];
    char stringdata0[446];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefFileformats_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefFileformats_t qt_meta_stringdata_lyx__frontend__PrefFileformats = {
    {
QT_MOC_LITERAL(0, 0, 30), // "lyx::frontend::PrefFileformats"
QT_MOC_LITERAL(1, 31, 14), // "formatsChanged"
QT_MOC_LITERAL(2, 46, 0), // ""
QT_MOC_LITERAL(3, 47, 22), // "on_copierED_textEdited"
QT_MOC_LITERAL(4, 70, 1), // "s"
QT_MOC_LITERAL(5, 72, 26), // "on_extensionsED_textEdited"
QT_MOC_LITERAL(6, 99, 22), // "on_viewerED_textEdited"
QT_MOC_LITERAL(7, 122, 22), // "on_editorED_textEdited"
QT_MOC_LITERAL(8, 145, 20), // "on_mimeED_textEdited"
QT_MOC_LITERAL(9, 166, 24), // "on_shortcutED_textEdited"
QT_MOC_LITERAL(10, 191, 27), // "on_formatED_editingFinished"
QT_MOC_LITERAL(11, 219, 23), // "on_formatED_textChanged"
QT_MOC_LITERAL(12, 243, 32), // "on_formatsCB_currentIndexChanged"
QT_MOC_LITERAL(13, 276, 28), // "on_formatsCB_editTextChanged"
QT_MOC_LITERAL(14, 305, 22), // "on_formatNewPB_clicked"
QT_MOC_LITERAL(15, 328, 25), // "on_formatRemovePB_clicked"
QT_MOC_LITERAL(16, 354, 31), // "on_viewerCO_currentIndexChanged"
QT_MOC_LITERAL(17, 386, 1), // "i"
QT_MOC_LITERAL(18, 388, 31), // "on_editorCO_currentIndexChanged"
QT_MOC_LITERAL(19, 420, 8), // "setFlags"
QT_MOC_LITERAL(20, 429, 16) // "updatePrettyname"

    },
    "lyx::frontend::PrefFileformats\0"
    "formatsChanged\0\0on_copierED_textEdited\0"
    "s\0on_extensionsED_textEdited\0"
    "on_viewerED_textEdited\0on_editorED_textEdited\0"
    "on_mimeED_textEdited\0on_shortcutED_textEdited\0"
    "on_formatED_editingFinished\0"
    "on_formatED_textChanged\0"
    "on_formatsCB_currentIndexChanged\0"
    "on_formatsCB_editTextChanged\0"
    "on_formatNewPB_clicked\0on_formatRemovePB_clicked\0"
    "on_viewerCO_currentIndexChanged\0i\0"
    "on_editorCO_currentIndexChanged\0"
    "setFlags\0updatePrettyname"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefFileformats[] = {

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

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

 // slots: name, argc, parameters, tag, flags
       3,    1,  100,    2, 0x08 /* Private */,
       5,    1,  103,    2, 0x08 /* Private */,
       6,    1,  106,    2, 0x08 /* Private */,
       7,    1,  109,    2, 0x08 /* Private */,
       8,    1,  112,    2, 0x08 /* Private */,
       9,    1,  115,    2, 0x08 /* Private */,
      10,    0,  118,    2, 0x08 /* Private */,
      11,    1,  119,    2, 0x08 /* Private */,
      12,    1,  122,    2, 0x08 /* Private */,
      13,    1,  125,    2, 0x08 /* Private */,
      14,    0,  128,    2, 0x08 /* Private */,
      15,    0,  129,    2, 0x08 /* Private */,
      16,    1,  130,    2, 0x08 /* Private */,
      18,    1,  133,    2, 0x08 /* Private */,
      19,    0,  136,    2, 0x08 /* Private */,
      20,    0,  137,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,    4,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void, QMetaType::Int,    2,
    QMetaType::Void, QMetaType::QString,    2,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Int,   17,
    QMetaType::Void, QMetaType::Int,   17,
    QMetaType::Void,
    QMetaType::Void,

       0        // eod
};

void lyx::frontend::PrefFileformats::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefFileformats *_t = static_cast<PrefFileformats *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->formatsChanged(); break;
        case 1: _t->on_copierED_textEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 2: _t->on_extensionsED_textEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 3: _t->on_viewerED_textEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 4: _t->on_editorED_textEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 5: _t->on_mimeED_textEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 6: _t->on_shortcutED_textEdited((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 7: _t->on_formatED_editingFinished(); break;
        case 8: _t->on_formatED_textChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 9: _t->on_formatsCB_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 10: _t->on_formatsCB_editTextChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 11: _t->on_formatNewPB_clicked(); break;
        case 12: _t->on_formatRemovePB_clicked(); break;
        case 13: _t->on_viewerCO_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 14: _t->on_editorCO_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 15: _t->setFlags(); break;
        case 16: _t->updatePrettyname(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            typedef void (PrefFileformats::*_t)();
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&PrefFileformats::formatsChanged)) {
                *result = 0;
                return;
            }
        }
    }
}

const QMetaObject lyx::frontend::PrefFileformats::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefFileformats.data,
      qt_meta_data_lyx__frontend__PrefFileformats,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefFileformats::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefFileformats.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefFileformatsUi"))
        return static_cast< Ui::PrefFileformatsUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

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

// SIGNAL 0
void lyx::frontend::PrefFileformats::formatsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
struct qt_meta_stringdata_lyx__frontend__PrefLanguage_t {
    QByteArrayData data[5];
    char stringdata0[149];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefLanguage_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefLanguage_t qt_meta_stringdata_lyx__frontend__PrefLanguage = {
    {
QT_MOC_LITERAL(0, 0, 27), // "lyx::frontend::PrefLanguage"
QT_MOC_LITERAL(1, 28, 35), // "on_uiLanguageCO_currentIndexC..."
QT_MOC_LITERAL(2, 64, 0), // ""
QT_MOC_LITERAL(3, 65, 40), // "on_languagePackageCO_currentI..."
QT_MOC_LITERAL(4, 106, 42) // "on_defaultDecimalSepCO_curren..."

    },
    "lyx::frontend::PrefLanguage\0"
    "on_uiLanguageCO_currentIndexChanged\0"
    "\0on_languagePackageCO_currentIndexChanged\0"
    "on_defaultDecimalSepCO_currentIndexChanged"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefLanguage[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    1,   29,    2, 0x08 /* Private */,
       3,    1,   32,    2, 0x08 /* Private */,
       4,    1,   35,    2, 0x08 /* Private */,

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

       0        // eod
};

void lyx::frontend::PrefLanguage::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefLanguage *_t = static_cast<PrefLanguage *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->on_uiLanguageCO_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 1: _t->on_languagePackageCO_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 2: _t->on_defaultDecimalSepCO_currentIndexChanged((*reinterpret_cast< int(*)>(_a[1]))); break;
        default: ;
        }
    }
}

const QMetaObject lyx::frontend::PrefLanguage::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefLanguage.data,
      qt_meta_data_lyx__frontend__PrefLanguage,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefLanguage::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefLanguage.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefLanguageUi"))
        return static_cast< Ui::PrefLanguageUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefLanguage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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;
}
struct qt_meta_stringdata_lyx__frontend__PrefUserInterface_t {
    QByteArrayData data[3];
    char stringdata0[43];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefUserInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefUserInterface_t qt_meta_stringdata_lyx__frontend__PrefUserInterface = {
    {
QT_MOC_LITERAL(0, 0, 32), // "lyx::frontend::PrefUserInterface"
QT_MOC_LITERAL(1, 33, 8), // "selectUi"
QT_MOC_LITERAL(2, 42, 0) // ""

    },
    "lyx::frontend::PrefUserInterface\0"
    "selectUi\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefUserInterface[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefUserInterface::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefUserInterface.data,
      qt_meta_data_lyx__frontend__PrefUserInterface,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefUserInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefUserInterface.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefUi"))
        return static_cast< Ui::PrefUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefUserInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefDocHandling_t {
    QByteArrayData data[3];
    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_lyx__frontend__PrefDocHandling_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefDocHandling_t qt_meta_stringdata_lyx__frontend__PrefDocHandling = {
    {
QT_MOC_LITERAL(0, 0, 30), // "lyx::frontend::PrefDocHandling"
QT_MOC_LITERAL(1, 31, 25), // "on_clearSessionPB_clicked"
QT_MOC_LITERAL(2, 57, 0) // ""

    },
    "lyx::frontend::PrefDocHandling\0"
    "on_clearSessionPB_clicked\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefDocHandling[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefDocHandling::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefDocHandling.data,
      qt_meta_data_lyx__frontend__PrefDocHandling,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefDocHandling::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefDocHandling.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefDocHandlingUi"))
        return static_cast< Ui::PrefDocHandlingUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefDocHandling::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__PrefEdit_t {
    QByteArrayData data[4];
    char stringdata0[78];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefEdit_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefEdit_t qt_meta_stringdata_lyx__frontend__PrefEdit = {
    {
QT_MOC_LITERAL(0, 0, 23), // "lyx::frontend::PrefEdit"
QT_MOC_LITERAL(1, 24, 24), // "on_screenLimitCB_toggled"
QT_MOC_LITERAL(2, 49, 0), // ""
QT_MOC_LITERAL(3, 50, 27) // "on_citationSearchCB_toggled"

    },
    "lyx::frontend::PrefEdit\0"
    "on_screenLimitCB_toggled\0\0"
    "on_citationSearchCB_toggled"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefEdit[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    2, 0x0a /* Public */,
       3,    1,   27,    2, 0x0a /* Public */,

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

       0        // eod
};

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

const QMetaObject lyx::frontend::PrefEdit::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefEdit.data,
      qt_meta_data_lyx__frontend__PrefEdit,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefEdit::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefEdit.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefEditUi"))
        return static_cast< Ui::PrefEditUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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_lyx__frontend__GuiShortcutDialog_t {
    QByteArrayData data[3];
    char stringdata0[56];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__GuiShortcutDialog_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__GuiShortcutDialog_t qt_meta_stringdata_lyx__frontend__GuiShortcutDialog = {
    {
QT_MOC_LITERAL(0, 0, 32), // "lyx::frontend::GuiShortcutDialog"
QT_MOC_LITERAL(1, 33, 21), // "on_lfunLE_textChanged"
QT_MOC_LITERAL(2, 55, 0) // ""

    },
    "lyx::frontend::GuiShortcutDialog\0"
    "on_lfunLE_textChanged\0"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__GuiShortcutDialog[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   19,    2, 0x0a /* Public */,

 // slots: parameters
    QMetaType::Void,

       0        // eod
};

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

const QMetaObject lyx::frontend::GuiShortcutDialog::staticMetaObject = {
    { &QDialog::staticMetaObject, qt_meta_stringdata_lyx__frontend__GuiShortcutDialog.data,
      qt_meta_data_lyx__frontend__GuiShortcutDialog,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::GuiShortcutDialog::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__GuiShortcutDialog.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::shortcutUi"))
        return static_cast< Ui::shortcutUi*>(this);
    return QDialog::qt_metacast(_clname);
}

int lyx::frontend::GuiShortcutDialog::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 < 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_lyx__frontend__PrefShortcuts_t {
    QByteArrayData data[13];
    char stringdata0[273];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefShortcuts_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefShortcuts_t qt_meta_stringdata_lyx__frontend__PrefShortcuts = {
    {
QT_MOC_LITERAL(0, 0, 28), // "lyx::frontend::PrefShortcuts"
QT_MOC_LITERAL(1, 29, 10), // "selectBind"
QT_MOC_LITERAL(2, 40, 0), // ""
QT_MOC_LITERAL(3, 41, 19), // "on_modifyPB_pressed"
QT_MOC_LITERAL(4, 61, 16), // "on_newPB_pressed"
QT_MOC_LITERAL(5, 78, 19), // "on_removePB_pressed"
QT_MOC_LITERAL(6, 98, 22), // "on_searchLE_textEdited"
QT_MOC_LITERAL(7, 121, 35), // "on_shortcutsTW_itemSelectionC..."
QT_MOC_LITERAL(8, 157, 32), // "on_shortcutsTW_itemDoubleClicked"
QT_MOC_LITERAL(9, 190, 17), // "shortcutOkPressed"
QT_MOC_LITERAL(10, 208, 21), // "shortcutCancelPressed"
QT_MOC_LITERAL(11, 230, 20), // "shortcutClearPressed"
QT_MOC_LITERAL(12, 251, 21) // "shortcutRemovePressed"

    },
    "lyx::frontend::PrefShortcuts\0selectBind\0"
    "\0on_modifyPB_pressed\0on_newPB_pressed\0"
    "on_removePB_pressed\0on_searchLE_textEdited\0"
    "on_shortcutsTW_itemSelectionChanged\0"
    "on_shortcutsTW_itemDoubleClicked\0"
    "shortcutOkPressed\0shortcutCancelPressed\0"
    "shortcutClearPressed\0shortcutRemovePressed"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefShortcuts[] = {

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

 // slots: name, argc, parameters, tag, flags
       1,    0,   69,    2, 0x0a /* Public */,
       3,    0,   70,    2, 0x0a /* Public */,
       4,    0,   71,    2, 0x0a /* Public */,
       5,    0,   72,    2, 0x0a /* Public */,
       6,    0,   73,    2, 0x0a /* Public */,
       7,    0,   74,    2, 0x0a /* Public */,
       8,    0,   75,    2, 0x0a /* Public */,
       9,    0,   76,    2, 0x0a /* Public */,
      10,    0,   77,    2, 0x0a /* Public */,
      11,    0,   78,    2, 0x0a /* Public */,
      12,    0,   79,    2, 0x0a /* Public */,

 // slots: parameters
    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 lyx::frontend::PrefShortcuts::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        PrefShortcuts *_t = static_cast<PrefShortcuts *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->selectBind(); break;
        case 1: _t->on_modifyPB_pressed(); break;
        case 2: _t->on_newPB_pressed(); break;
        case 3: _t->on_removePB_pressed(); break;
        case 4: _t->on_searchLE_textEdited(); break;
        case 5: _t->on_shortcutsTW_itemSelectionChanged(); break;
        case 6: _t->on_shortcutsTW_itemDoubleClicked(); break;
        case 7: _t->shortcutOkPressed(); break;
        case 8: _t->shortcutCancelPressed(); break;
        case 9: _t->shortcutClearPressed(); break;
        case 10: _t->shortcutRemovePressed(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

const QMetaObject lyx::frontend::PrefShortcuts::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefShortcuts.data,
      qt_meta_data_lyx__frontend__PrefShortcuts,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefShortcuts::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefShortcuts.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefShortcuts"))
        return static_cast< Ui::PrefShortcuts*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefShortcuts::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::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;
}
struct qt_meta_stringdata_lyx__frontend__PrefIdentity_t {
    QByteArrayData data[1];
    char stringdata0[28];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_lyx__frontend__PrefIdentity_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_lyx__frontend__PrefIdentity_t qt_meta_stringdata_lyx__frontend__PrefIdentity = {
    {
QT_MOC_LITERAL(0, 0, 27) // "lyx::frontend::PrefIdentity"

    },
    "lyx::frontend::PrefIdentity"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_lyx__frontend__PrefIdentity[] = {

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

       0        // eod
};

void lyx::frontend::PrefIdentity::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    Q_UNUSED(_o);
    Q_UNUSED(_id);
    Q_UNUSED(_c);
    Q_UNUSED(_a);
}

const QMetaObject lyx::frontend::PrefIdentity::staticMetaObject = {
    { &PrefModule::staticMetaObject, qt_meta_stringdata_lyx__frontend__PrefIdentity.data,
      qt_meta_data_lyx__frontend__PrefIdentity,  qt_static_metacall, nullptr, nullptr}
};


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

void *lyx::frontend::PrefIdentity::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_lyx__frontend__PrefIdentity.stringdata0))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::PrefIdentityUi"))
        return static_cast< Ui::PrefIdentityUi*>(this);
    return PrefModule::qt_metacast(_clname);
}

int lyx::frontend::PrefIdentity::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PrefModule::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
