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

#include "GuiPrefs.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'GuiPrefs.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::GuiPreferences::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::GuiPreferences",
        "prefsApplied",
        "",
        "LyXRC",
        "rc",
        "change_adaptor",
        "slotFileSelected"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'prefsApplied'
        QtMocHelpers::SignalData<void(LyXRC const &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'change_adaptor'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotFileSelected'
        QtMocHelpers::SlotData<void(QString)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<GuiPreferences, qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::GuiPreferences::staticMetaObject = { {
    QMetaObject::SuperData::link<GuiDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14GuiPreferencesE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void lyx::frontend::GuiPreferences::prefsApplied(LyXRC const & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefModule::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefModule",
        "changed",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'changed'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefModule, qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefModule::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefModule::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefModule *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->changed(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PrefModule::*)()>(_a, &PrefModule::changed, 0))
            return;
    }
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefModuleE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void lyx::frontend::PrefModule::changed()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefOutput::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefOutput"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefOutput, qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefOutput::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefOutput::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefOutput *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefOutputE_t>.strings))
        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;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend9PrefInputE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefInput::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend9PrefInputE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefInput",
        "on_firstKeymapPB_clicked",
        "",
        "on_secondKeymapPB_clicked",
        "on_keymapCB_toggled",
        "on_scrollzoomEnableCB_toggled"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_firstKeymapPB_clicked'
        QtMocHelpers::SlotData<void(bool)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'on_secondKeymapPB_clicked'
        QtMocHelpers::SlotData<void(bool)>(3, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'on_keymapCB_toggled'
        QtMocHelpers::SlotData<void(bool)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'on_scrollzoomEnableCB_toggled'
        QtMocHelpers::SlotData<void(bool)>(5, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefInput, qt_meta_tag_ZN3lyx8frontend9PrefInputE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefInput::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefInputE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefInputE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend9PrefInputE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefInputE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 4;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefCompletion::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefCompletion",
        "on_popupTextCB_clicked",
        "",
        "on_inlineTextCB_clicked"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_popupTextCB_clicked'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'on_inlineTextCB_clicked'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefCompletion, qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefCompletion::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14PrefCompletionE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefLatex::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefLatex",
        "on_latexBibtexCO_activated",
        "",
        "n",
        "on_latexJBibtexCO_activated",
        "on_latexIndexCO_activated"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_latexBibtexCO_activated'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'on_latexJBibtexCO_activated'
        QtMocHelpers::SlotData<void(int)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'on_latexIndexCO_activated'
        QtMocHelpers::SlotData<void(int)>(5, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefLatex, qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefLatex::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefLatexE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefScreenFonts::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefScreenFonts",
        "selectRoman",
        "",
        "selectSans",
        "selectTypewriter",
        "screenFontsChanged",
        "updateScreenFontSizes",
        "LyXRC",
        "rc"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'selectRoman'
        QtMocHelpers::SlotData<void(const QString &)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'selectSans'
        QtMocHelpers::SlotData<void(const QString &)>(3, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'selectTypewriter'
        QtMocHelpers::SlotData<void(const QString &)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'screenFontsChanged'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateScreenFontSizes'
        QtMocHelpers::SlotData<void(LyXRC const &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefScreenFonts, qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefScreenFonts::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefScreenFontsE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefColors::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefColors",
        "onColorsTVClicked",
        "",
        "QModelIndex",
        "index",
        "onRejected",
        "selectionChanged",
        "QItemSelection",
        "selected",
        "deselected",
        "resetAllColor",
        "changeSysColor",
        "changeAutoapply",
        "setColor",
        "QStandardItem*",
        "item",
        "QColor",
        "new_color",
        "old_color",
        "editLightColor",
        "editDarkColor",
        "resetColors",
        "resetLightColor",
        "resetDarkColor",
        "openThemeMenu",
        "saveTheme",
        "loadTheme",
        "row",
        "QListWidgetItem*",
        "removeTheme",
        "exportTheme",
        "importTheme",
        "filterByColorName",
        "text",
        "filterByColor",
        "color",
        "clearFilter",
        "openColorChooser"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onColorsTVClicked'
        QtMocHelpers::SlotData<void(const QModelIndex)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'onRejected'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectionChanged'
        QtMocHelpers::SlotData<void(const QItemSelection &, const QItemSelection &)>(6, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 7, 8 }, { 0x80000000 | 7, 9 },
        }}),
        // Slot 'resetAllColor'
        QtMocHelpers::SlotData<bool()>(10, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'changeSysColor'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'changeAutoapply'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setColor'
        QtMocHelpers::SlotData<bool(QStandardItem *, QColor const &, QString const &)>(13, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { 0x80000000 | 14, 15 }, { 0x80000000 | 16, 17 }, { QMetaType::QString, 18 },
        }}),
        // Slot 'editLightColor'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editDarkColor'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'resetColors'
        QtMocHelpers::SlotData<bool()>(21, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'resetLightColor'
        QtMocHelpers::SlotData<bool()>(22, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'resetDarkColor'
        QtMocHelpers::SlotData<bool()>(23, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'openThemeMenu'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'saveTheme'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'loadTheme'
        QtMocHelpers::SlotData<void(int const)>(26, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 27 },
        }}),
        // Slot 'loadTheme'
        QtMocHelpers::SlotData<void(QListWidgetItem *)>(26, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 28, 15 },
        }}),
        // Slot 'removeTheme'
        QtMocHelpers::SlotData<void()>(29, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'exportTheme'
        QtMocHelpers::SlotData<void()>(30, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'importTheme'
        QtMocHelpers::SlotData<void()>(31, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'filterByColorName'
        QtMocHelpers::SlotData<void(const QString &) const>(32, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 33 },
        }}),
        // Slot 'filterByColor'
        QtMocHelpers::SlotData<void(const QColor &)>(34, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 16, 35 },
        }}),
        // Slot 'clearFilter'
        QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openColorChooser'
        QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefColors, qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefColors::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefColors::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefColors *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onColorsTVClicked((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 1: _t->onRejected(); break;
        case 2: _t->selectionChanged((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[2]))); break;
        case 3: { bool _r = _t->resetAllColor();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 4: _t->changeSysColor(); break;
        case 5: _t->changeAutoapply(); break;
        case 6: { bool _r = _t->setColor((*reinterpret_cast<std::add_pointer_t<QStandardItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 7: _t->editLightColor(); break;
        case 8: _t->editDarkColor(); break;
        case 9: { bool _r = _t->resetColors();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 10: { bool _r = _t->resetLightColor();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 11: { bool _r = _t->resetDarkColor();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 12: _t->openThemeMenu(); break;
        case 13: _t->saveTheme(); break;
        case 14: _t->loadTheme((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 15: _t->loadTheme((*reinterpret_cast<std::add_pointer_t<QListWidgetItem*>>(_a[1]))); break;
        case 16: _t->removeTheme(); break;
        case 17: _t->exportTheme(); break;
        case 18: _t->importTheme(); break;
        case 19: _t->filterByColorName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->filterByColor((*reinterpret_cast<std::add_pointer_t<QColor>>(_a[1]))); break;
        case 21: _t->clearFilter(); break;
        case 22: _t->openColorChooser(); break;
        default: ;
        }
    }
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend10PrefColorsE_t>.strings))
        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 < 23)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 23;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 23)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 23;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefDisplay::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefDisplay",
        "on_instantPreviewCO_currentIndexChanged",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_instantPreviewCO_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefDisplay, qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefDisplay::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend11PrefDisplayE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefPaths::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefPaths",
        "selectExampledir",
        "",
        "selectTemplatedir",
        "selectTempdir",
        "selectBackupdir",
        "selectWorkingdir",
        "selectThesaurusdir",
        "selectHunspelldir",
        "selectLyxPipe"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'selectExampledir'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectTemplatedir'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectTempdir'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectBackupdir'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectWorkingdir'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectThesaurusdir'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectHunspelldir'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectLyxPipe'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefPaths, qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefPaths::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefPaths::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefPaths *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        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: ;
        }
    }
    (void)_a;
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend9PrefPathsE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefSpellchecker::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefSpellchecker",
        "on_spellcheckerCB_currentIndexChanged",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_spellcheckerCB_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefSpellchecker, qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefSpellchecker::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend16PrefSpellcheckerE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefConverters::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefConverters",
        "updateGui",
        "",
        "updateConverter",
        "switchConverter",
        "removeConverter",
        "changeConverter",
        "on_cacheCB_stateChanged",
        "state",
        "on_needauthForbiddenCB_toggled",
        "on_needauthCB_toggled"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'updateGui'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateConverter'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'switchConverter'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'removeConverter'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'changeConverter'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'on_cacheCB_stateChanged'
        QtMocHelpers::SlotData<void(int)>(7, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 8 },
        }}),
        // Slot 'on_needauthForbiddenCB_toggled'
        QtMocHelpers::SlotData<void(bool)>(9, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'on_needauthCB_toggled'
        QtMocHelpers::SlotData<void(bool)>(10, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefConverters, qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefConverters::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefConverters::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefConverters *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        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<std::add_pointer_t<int>>(_a[1]))); break;
        case 6: _t->on_needauthForbiddenCB_toggled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->on_needauthCB_toggled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend14PrefConvertersE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefFileformats::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefFileformats",
        "formatsChanged",
        "",
        "on_copierED_textEdited",
        "s",
        "on_extensionsED_textEdited",
        "on_viewerED_textEdited",
        "on_editorED_textEdited",
        "on_mimeED_textEdited",
        "on_shortcutED_textEdited",
        "on_formatED_editingFinished",
        "on_formatED_textChanged",
        "on_formatsCB_currentIndexChanged",
        "on_formatsCB_editTextChanged",
        "on_formatNewPB_clicked",
        "on_formatRemovePB_clicked",
        "on_viewerCO_currentIndexChanged",
        "i",
        "on_editorCO_currentIndexChanged",
        "setFlags",
        "updatePrettyname"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'formatsChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_copierED_textEdited'
        QtMocHelpers::SlotData<void(const QString &)>(3, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'on_extensionsED_textEdited'
        QtMocHelpers::SlotData<void(const QString &)>(5, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_viewerED_textEdited'
        QtMocHelpers::SlotData<void(const QString &)>(6, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_editorED_textEdited'
        QtMocHelpers::SlotData<void(const QString &)>(7, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_mimeED_textEdited'
        QtMocHelpers::SlotData<void(const QString &)>(8, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_shortcutED_textEdited'
        QtMocHelpers::SlotData<void(const QString &)>(9, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_formatED_editingFinished'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'on_formatED_textChanged'
        QtMocHelpers::SlotData<void(const QString &)>(11, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_formatsCB_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(12, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Slot 'on_formatsCB_editTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(13, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'on_formatNewPB_clicked'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'on_formatRemovePB_clicked'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'on_viewerCO_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(16, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'on_editorCO_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(18, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'setFlags'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updatePrettyname'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefFileformats, qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefFileformats::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefFileformats::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefFileformats *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->formatsChanged(); break;
        case 1: _t->on_copierED_textEdited((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->on_extensionsED_textEdited((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->on_viewerED_textEdited((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->on_editorED_textEdited((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->on_mimeED_textEdited((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->on_shortcutED_textEdited((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->on_formatED_editingFinished(); break;
        case 8: _t->on_formatED_textChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 9: _t->on_formatsCB_currentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->on_formatsCB_editTextChanged((*reinterpret_cast<std::add_pointer_t<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<std::add_pointer_t<int>>(_a[1]))); break;
        case 14: _t->on_editorCO_currentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 15: _t->setFlags(); break;
        case 16: _t->updatePrettyname(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PrefFileformats::*)()>(_a, &PrefFileformats::formatsChanged, 0))
            return;
    }
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefFileformatsE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 17)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 17;
    }
    return _id;
}

// SIGNAL 0
void lyx::frontend::PrefFileformats::formatsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefLanguage::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefLanguage",
        "on_uiLanguageCO_currentIndexChanged",
        "",
        "on_languagePackageCO_currentIndexChanged",
        "on_defaultDecimalSepCO_currentIndexChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_uiLanguageCO_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Slot 'on_languagePackageCO_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(3, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Slot 'on_defaultDecimalSepCO_currentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefLanguage, qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefLanguage::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend12PrefLanguageE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefUserInterface::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefUserInterface",
        "selectUi",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'selectUi'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefUserInterface, qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefUserInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend17PrefUserInterfaceE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefDocHandling::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefDocHandling",
        "on_clearSessionPB_clicked",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_clearSessionPB_clicked'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefDocHandling, qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefDocHandling::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend15PrefDocHandlingE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend8PrefEditE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefEdit::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend8PrefEditE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefEdit",
        "on_screenLimitCB_toggled",
        "",
        "on_citationSearchCB_toggled"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_screenLimitCB_toggled'
        QtMocHelpers::SlotData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'on_citationSearchCB_toggled'
        QtMocHelpers::SlotData<void(bool)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefEdit, qt_meta_tag_ZN3lyx8frontend8PrefEditE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefEdit::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend8PrefEditE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend8PrefEditE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend8PrefEditE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend8PrefEditE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::GuiShortcutDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::GuiShortcutDialog",
        "on_lfunLE_textChanged",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'on_lfunLE_textChanged'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<GuiShortcutDialog, qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::GuiShortcutDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t>.metaTypes,
    nullptr
} };

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

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend17GuiShortcutDialogE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefShortcuts::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefShortcuts",
        "selectBind",
        "",
        "on_modifyPB_pressed",
        "on_newPB_pressed",
        "on_removePB_pressed",
        "on_searchLE_textEdited",
        "on_shortcutsTW_itemSelectionChanged",
        "on_shortcutsTW_itemDoubleClicked",
        "shortcutOkPressed",
        "shortcutCancelPressed",
        "shortcutClearPressed",
        "shortcutRemovePressed"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'selectBind'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_modifyPB_pressed'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_newPB_pressed'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_removePB_pressed'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_searchLE_textEdited'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_shortcutsTW_itemSelectionChanged'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'on_shortcutsTW_itemDoubleClicked'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'shortcutOkPressed'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'shortcutCancelPressed'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'shortcutClearPressed'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'shortcutRemovePressed'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefShortcuts, qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefShortcuts::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefShortcuts::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefShortcuts *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        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: ;
        }
    }
    (void)_a;
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend13PrefShortcutsE_t>.strings))
        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;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 11)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 11;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::PrefIdentity::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::PrefIdentity"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PrefIdentity, qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::PrefIdentity::staticMetaObject = { {
    QMetaObject::SuperData::link<PrefModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::PrefIdentity::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PrefIdentity *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend12PrefIdentityE_t>.strings))
        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;
}
namespace {
struct qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t {};
} // unnamed namespace

template <> constexpr inline auto lyx::frontend::ColorSwatchDelegate::qt_create_metaobjectdata<qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "lyx::frontend::ColorSwatchDelegate"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ColorSwatchDelegate, qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject lyx::frontend::ColorSwatchDelegate::staticMetaObject = { {
    QMetaObject::SuperData::link<QStyledItemDelegate::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t>.metaTypes,
    nullptr
} };

void lyx::frontend::ColorSwatchDelegate::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ColorSwatchDelegate *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *lyx::frontend::ColorSwatchDelegate::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3lyx8frontend19ColorSwatchDelegateE_t>.strings))
        return static_cast<void*>(this);
    return QStyledItemDelegate::qt_metacast(_clname);
}

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