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

#include "../../../texstudio-4.9.5/src/latexdocument.h"
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QSharedPointer>
#include <QtCore/QList>
#include <QtCore/QSet>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'latexdocument.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN13LatexDocumentE_t {};
} // unnamed namespace

template <> constexpr inline auto LatexDocument::qt_create_metaobjectdata<qt_meta_tag_ZN13LatexDocumentE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LatexDocument",
        "structureUpdated",
        "",
        "updateCompleter",
        "updateCompleterCommands",
        "updateBibTeXFiles",
        "importPackage",
        "name",
        "spellingDictChanged",
        "encodingChanged",
        "bookmarkLineUpdated",
        "lineNr",
        "updateStructure",
        "patchStructure",
        "linenr",
        "count",
        "recheck",
        "patchStructureRemoval",
        "QDocumentLineHandle*",
        "dlh",
        "hint",
        "initClearStructure",
        "updateLtxCommands",
        "updateAll",
        "updatePackages",
        "addLtxCommands",
        "setLtxCommands",
        "QSharedPointer<LatexParser>",
        "cmds",
        "setSpeller",
        "SpellerUtility*",
        "speller",
        "setReplacementList",
        "QMap<QString,QString>",
        "replacementList",
        "updateSettings",
        "checkNextLine",
        "clearOverlay",
        "ticket",
        "getEditorView",
        "LatexEditorView*",
        "labelItems",
        "refItems",
        "bibItems",
        "userCommandList",
        "QList<CodeSnippet>",
        "additionalCommandsList",
        "CodeSnippetList",
        "QStringList&",
        "loadedFiles",
        "countLabels",
        "countRefs",
        "bibIdValid",
        "isBibItem",
        "findFileFromBibId",
        "getLabels",
        "QMultiHash<QDocumentLineHandle*,int>",
        "getRefs",
        "getBibItems",
        "findCommandDefinition",
        "findUsePackage",
        "replaceItems",
        "QMultiHash<QDocumentLineHandle*,ReferencePair>",
        "items",
        "newName",
        "QDocumentCursor*",
        "cursor",
        "replaceLabel",
        "replaceRefs",
        "replaceLabelsAndRefs",
        "getTemporaryFileName",
        "getFileNameOrTemporaryFileName",
        "getTemporaryFileInfo",
        "QFileInfo",
        "getAbsoluteFilePath",
        "relName",
        "extension",
        "additionalSearchPaths",
        "getMasterDocument",
        "LatexDocument*",
        "getRootDocument",
        "getTopMasterDocument",
        "includedFiles",
        "importsOnly",
        "includedFilesAndParent",
        "getListOfDocs",
        "QList<LatexDocument*>",
        "QSet<LatexDocument*>*",
        "visitedDocs",
        "onlyChildDocs",
        "containsPackage",
        "containedPackages",
        "usedPackages",
        "QSet<QString>",
        "onlyInChildDocs",
        "spellingDictName",
        "getMagicComment",
        "getMagicCommentEntry",
        "StructureEntry*",
        "updateMagicComment",
        "val",
        "createIfNonExisting",
        "prefix",
        "getLastEnvName",
        "lineNumber",
        "isSubfileRoot",
        "fileName",
        "fileInfo",
        "editorView"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'structureUpdated'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateCompleter'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateCompleterCommands'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateBibTeXFiles'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'importPackage'
        QtMocHelpers::SignalData<void(QString)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Signal 'spellingDictChanged'
        QtMocHelpers::SignalData<void(const QString &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Signal 'encodingChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'bookmarkLineUpdated'
        QtMocHelpers::SignalData<void(int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'updateStructure'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'patchStructure'
        QtMocHelpers::SlotData<void(int, int, bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 }, { QMetaType::Int, 15 }, { QMetaType::Bool, 16 },
        }}),
        // Slot 'patchStructure'
        QtMocHelpers::SlotData<void(int, int)>(13, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 14 }, { QMetaType::Int, 15 },
        }}),
        // Slot 'patchStructureRemoval'
        QtMocHelpers::SlotData<void(QDocumentLineHandle *, int, int)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::Int, 20 }, { QMetaType::Int, 15 },
        }}),
        // Slot 'patchStructureRemoval'
        QtMocHelpers::SlotData<void(QDocumentLineHandle *, int)>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::Int, 20 },
        }}),
        // Slot 'patchStructureRemoval'
        QtMocHelpers::SlotData<void(QDocumentLineHandle *)>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Slot 'initClearStructure'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateLtxCommands'
        QtMocHelpers::SlotData<void(bool, bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 }, { QMetaType::Bool, 24 },
        }}),
        // Slot 'updateLtxCommands'
        QtMocHelpers::SlotData<void(bool)>(22, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'updateLtxCommands'
        QtMocHelpers::SlotData<void()>(22, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'addLtxCommands'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setLtxCommands'
        QtMocHelpers::SlotData<void(QSharedPointer<LatexParser>)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Slot 'setSpeller'
        QtMocHelpers::SlotData<void(SpellerUtility *)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 30, 31 },
        }}),
        // Slot 'setReplacementList'
        QtMocHelpers::SlotData<void(QMap<QString,QString>)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 34 },
        }}),
        // Slot 'updateSettings'
        QtMocHelpers::SlotData<void()>(35, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkNextLine'
        QtMocHelpers::SlotData<void(QDocumentLineHandle *, bool, int, int)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::Bool, 37 }, { QMetaType::Int, 38 }, { QMetaType::Int, 20 },
        }}),
        // Slot 'checkNextLine'
        QtMocHelpers::SlotData<void(QDocumentLineHandle *, bool, int)>(36, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 18, 19 }, { QMetaType::Bool, 37 }, { QMetaType::Int, 38 },
        }}),
        // Method 'getEditorView'
        QtMocHelpers::MethodData<LatexEditorView *() const>(39, 2, QMC::AccessPublic, 0x80000000 | 40),
        // Method 'labelItems'
        QtMocHelpers::MethodData<QStringList() const>(41, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'refItems'
        QtMocHelpers::MethodData<QStringList() const>(42, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'bibItems'
        QtMocHelpers::MethodData<QStringList() const>(43, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'userCommandList'
        QtMocHelpers::MethodData<QList<CodeSnippet>() const>(44, 2, QMC::AccessPublic, 0x80000000 | 45),
        // Method 'additionalCommandsList'
        QtMocHelpers::MethodData<CodeSnippetList(QStringList &)>(46, 2, QMC::AccessPublic, 0x80000000 | 47, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Method 'countLabels'
        QtMocHelpers::MethodData<int(const QString &)>(50, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'countRefs'
        QtMocHelpers::MethodData<int(const QString &)>(51, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'bibIdValid'
        QtMocHelpers::MethodData<bool(const QString &)>(52, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'isBibItem'
        QtMocHelpers::MethodData<bool(const QString &)>(53, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'findFileFromBibId'
        QtMocHelpers::MethodData<QString(const QString &)>(54, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'getLabels'
        QtMocHelpers::MethodData<QMultiHash<QDocumentLineHandle*,int>(const QString &)>(55, 2, QMC::AccessPublic, 0x80000000 | 56, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'getRefs'
        QtMocHelpers::MethodData<QMultiHash<QDocumentLineHandle*,int>(const QString &)>(57, 2, QMC::AccessPublic, 0x80000000 | 56, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'getBibItems'
        QtMocHelpers::MethodData<QMultiHash<QDocumentLineHandle*,int>(const QString &)>(58, 2, QMC::AccessPublic, 0x80000000 | 56, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'findCommandDefinition'
        QtMocHelpers::MethodData<QDocumentLineHandle *(const QString &)>(59, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'findUsePackage'
        QtMocHelpers::MethodData<QDocumentLineHandle *(const QString &)>(60, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'replaceItems'
        QtMocHelpers::MethodData<void(QMultiHash<QDocumentLineHandle*,ReferencePair>, const QString &, QDocumentCursor *)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 }, { QMetaType::QString, 64 }, { 0x80000000 | 65, 66 },
        }}),
        // Method 'replaceItems'
        QtMocHelpers::MethodData<void(QMultiHash<QDocumentLineHandle*,ReferencePair>, const QString &)>(61, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 62, 63 }, { QMetaType::QString, 64 },
        }}),
        // Method 'replaceLabel'
        QtMocHelpers::MethodData<void(const QString &, const QString &, QDocumentCursor *)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 64 }, { 0x80000000 | 65, 66 },
        }}),
        // Method 'replaceLabel'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(67, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 64 },
        }}),
        // Method 'replaceRefs'
        QtMocHelpers::MethodData<void(const QString &, const QString &, QDocumentCursor *)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 64 }, { 0x80000000 | 65, 66 },
        }}),
        // Method 'replaceRefs'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(68, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 64 },
        }}),
        // Method 'replaceLabelsAndRefs'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 64 },
        }}),
        // Method 'getTemporaryFileName'
        QtMocHelpers::MethodData<QString() const>(70, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getFileNameOrTemporaryFileName'
        QtMocHelpers::MethodData<QString() const>(71, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getTemporaryFileInfo'
        QtMocHelpers::MethodData<QFileInfo() const>(72, 2, QMC::AccessPublic, 0x80000000 | 73),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &, const QString &, const QStringList &) const>(74, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 75 }, { QMetaType::QString, 76 }, { QMetaType::QStringList, 77 },
        }}),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &, const QString &) const>(74, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 75 }, { QMetaType::QString, 76 },
        }}),
        // Method 'getMasterDocument'
        QtMocHelpers::MethodData<LatexDocument *() const>(78, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Method 'getRootDocument'
        QtMocHelpers::MethodData<LatexDocument *()>(80, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Method 'getTopMasterDocument'
        QtMocHelpers::MethodData<LatexDocument *()>(81, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Method 'includedFiles'
        QtMocHelpers::MethodData<QStringList(bool)>(82, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::Bool, 83 },
        }}),
        // Method 'includedFiles'
        QtMocHelpers::MethodData<QStringList()>(82, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QStringList),
        // Method 'includedFilesAndParent'
        QtMocHelpers::MethodData<QStringList()>(84, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getListOfDocs'
        QtMocHelpers::MethodData<QList<LatexDocument*>(QSet<LatexDocument*> *, bool)>(85, 2, QMC::AccessPublic, 0x80000000 | 86, {{
            { 0x80000000 | 87, 88 }, { QMetaType::Bool, 89 },
        }}),
        // Method 'getListOfDocs'
        QtMocHelpers::MethodData<QList<LatexDocument*>(QSet<LatexDocument*> *)>(85, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 86, {{
            { 0x80000000 | 87, 88 },
        }}),
        // Method 'getListOfDocs'
        QtMocHelpers::MethodData<QList<LatexDocument*>()>(85, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 86),
        // Method 'containsPackage'
        QtMocHelpers::MethodData<bool(const QString &)>(90, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'containedPackages'
        QtMocHelpers::MethodData<QStringList()>(91, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'usedPackages'
        QtMocHelpers::MethodData<QSet<QString>(bool)>(92, 2, QMC::AccessPublic, 0x80000000 | 93, {{
            { QMetaType::Bool, 94 },
        }}),
        // Method 'usedPackages'
        QtMocHelpers::MethodData<QSet<QString>()>(92, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 93),
        // Method 'spellingDictName'
        QtMocHelpers::MethodData<QString() const>(95, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getMagicComment'
        QtMocHelpers::MethodData<QString(const QString &) const>(96, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'getMagicCommentEntry'
        QtMocHelpers::MethodData<StructureEntry *(const QString &) const>(97, 2, QMC::AccessPublic, 0x80000000 | 98, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'updateMagicComment'
        QtMocHelpers::MethodData<void(const QString &, const QString &, bool, QString)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 100 }, { QMetaType::Bool, 101 }, { QMetaType::QString, 102 },
        }}),
        // Method 'updateMagicComment'
        QtMocHelpers::MethodData<void(const QString &, const QString &, bool)>(99, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 100 }, { QMetaType::Bool, 101 },
        }}),
        // Method 'updateMagicComment'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(99, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 100 },
        }}),
        // Method 'getLastEnvName'
        QtMocHelpers::MethodData<QString(int)>(103, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 104 },
        }}),
        // Method 'isSubfileRoot'
        QtMocHelpers::MethodData<bool()>(105, 2, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'fileName'
        QtMocHelpers::PropertyData<QString>(106, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'fileInfo'
        QtMocHelpers::PropertyData<QFileInfo>(107, 0x80000000 | 73, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'editorView'
        QtMocHelpers::PropertyData<LatexEditorView*>(108, 0x80000000 | 40, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LatexDocument, qt_meta_tag_ZN13LatexDocumentE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LatexDocument::staticMetaObject = { {
    QMetaObject::SuperData::link<QDocument::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13LatexDocumentE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13LatexDocumentE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13LatexDocumentE_t>.metaTypes,
    nullptr
} };

void LatexDocument::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<LatexDocument *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->structureUpdated(); break;
        case 1: _t->updateCompleter(); break;
        case 2: _t->updateCompleterCommands(); break;
        case 3: _t->updateBibTeXFiles(); break;
        case 4: _t->importPackage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->spellingDictChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->encodingChanged(); break;
        case 7: _t->bookmarkLineUpdated((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->updateStructure(); break;
        case 9: _t->patchStructure((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 10: _t->patchStructure((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 11: _t->patchStructureRemoval((*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 12: _t->patchStructureRemoval((*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 13: _t->patchStructureRemoval((*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[1]))); break;
        case 14: _t->initClearStructure(); break;
        case 15: _t->updateLtxCommands((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 16: _t->updateLtxCommands((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->updateLtxCommands(); break;
        case 18: _t->addLtxCommands(); break;
        case 19: _t->setLtxCommands((*reinterpret_cast<std::add_pointer_t<QSharedPointer<LatexParser>>>(_a[1]))); break;
        case 20: _t->setSpeller((*reinterpret_cast<std::add_pointer_t<SpellerUtility*>>(_a[1]))); break;
        case 21: _t->setReplacementList((*reinterpret_cast<std::add_pointer_t<QMap<QString,QString>>>(_a[1]))); break;
        case 22: _t->updateSettings(); break;
        case 23: _t->checkNextLine((*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 24: _t->checkNextLine((*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 25: { LatexEditorView* _r = _t->getEditorView();
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 26: { QStringList _r = _t->labelItems();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 27: { QStringList _r = _t->refItems();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 28: { QStringList _r = _t->bibItems();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 29: { QList<CodeSnippet> _r = _t->userCommandList();
            if (_a[0]) *reinterpret_cast<QList<CodeSnippet>*>(_a[0]) = std::move(_r); }  break;
        case 30: { CodeSnippetList _r = _t->additionalCommandsList((*reinterpret_cast<std::add_pointer_t<QStringList&>>(_a[1])));
            if (_a[0]) *reinterpret_cast<CodeSnippetList*>(_a[0]) = std::move(_r); }  break;
        case 31: { int _r = _t->countLabels((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 32: { int _r = _t->countRefs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 33: { bool _r = _t->bibIdValid((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 34: { bool _r = _t->isBibItem((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 35: { QString _r = _t->findFileFromBibId((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 36: { QMultiHash<QDocumentLineHandle*,int> _r = _t->getLabels((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMultiHash<QDocumentLineHandle*,int>*>(_a[0]) = std::move(_r); }  break;
        case 37: { QMultiHash<QDocumentLineHandle*,int> _r = _t->getRefs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMultiHash<QDocumentLineHandle*,int>*>(_a[0]) = std::move(_r); }  break;
        case 38: { QMultiHash<QDocumentLineHandle*,int> _r = _t->getBibItems((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMultiHash<QDocumentLineHandle*,int>*>(_a[0]) = std::move(_r); }  break;
        case 39: { QDocumentLineHandle* _r = _t->findCommandDefinition((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDocumentLineHandle**>(_a[0]) = std::move(_r); }  break;
        case 40: { QDocumentLineHandle* _r = _t->findUsePackage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDocumentLineHandle**>(_a[0]) = std::move(_r); }  break;
        case 41: _t->replaceItems((*reinterpret_cast<std::add_pointer_t<QMultiHash<QDocumentLineHandle*,ReferencePair>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QDocumentCursor*>>(_a[3]))); break;
        case 42: _t->replaceItems((*reinterpret_cast<std::add_pointer_t<QMultiHash<QDocumentLineHandle*,ReferencePair>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 43: _t->replaceLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QDocumentCursor*>>(_a[3]))); break;
        case 44: _t->replaceLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 45: _t->replaceRefs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QDocumentCursor*>>(_a[3]))); break;
        case 46: _t->replaceRefs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 47: _t->replaceLabelsAndRefs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 48: { QString _r = _t->getTemporaryFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 49: { QString _r = _t->getFileNameOrTemporaryFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 50: { QFileInfo _r = _t->getTemporaryFileInfo();
            if (_a[0]) *reinterpret_cast<QFileInfo*>(_a[0]) = std::move(_r); }  break;
        case 51: { QString _r = _t->getAbsoluteFilePath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 52: { QString _r = _t->getAbsoluteFilePath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 53: { LatexDocument* _r = _t->getMasterDocument();
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 54: { LatexDocument* _r = _t->getRootDocument();
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 55: { LatexDocument* _r = _t->getTopMasterDocument();
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 56: { QStringList _r = _t->includedFiles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 57: { QStringList _r = _t->includedFiles();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 58: { QStringList _r = _t->includedFilesAndParent();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 59: { QList<LatexDocument*> _r = _t->getListOfDocs((*reinterpret_cast<std::add_pointer_t<QSet<LatexDocument*>*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QList<LatexDocument*>*>(_a[0]) = std::move(_r); }  break;
        case 60: { QList<LatexDocument*> _r = _t->getListOfDocs((*reinterpret_cast<std::add_pointer_t<QSet<LatexDocument*>*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<LatexDocument*>*>(_a[0]) = std::move(_r); }  break;
        case 61: { QList<LatexDocument*> _r = _t->getListOfDocs();
            if (_a[0]) *reinterpret_cast<QList<LatexDocument*>*>(_a[0]) = std::move(_r); }  break;
        case 62: { bool _r = _t->containsPackage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 63: { QStringList _r = _t->containedPackages();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 64: { QSet<QString> _r = _t->usedPackages((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSet<QString>*>(_a[0]) = std::move(_r); }  break;
        case 65: { QSet<QString> _r = _t->usedPackages();
            if (_a[0]) *reinterpret_cast<QSet<QString>*>(_a[0]) = std::move(_r); }  break;
        case 66: { QString _r = _t->spellingDictName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 67: { QString _r = _t->getMagicComment((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 68: { StructureEntry* _r = _t->getMagicCommentEntry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<StructureEntry**>(_a[0]) = std::move(_r); }  break;
        case 69: _t->updateMagicComment((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 70: _t->updateMagicComment((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 71: _t->updateMagicComment((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 72: { QString _r = _t->getLastEnvName((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 73: { bool _r = _t->isSubfileRoot();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentLineHandle* >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentLineHandle* >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentLineHandle* >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentLineHandle* >(); break;
            }
            break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentLineHandle* >(); break;
            }
            break;
        case 41:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor* >(); break;
            }
            break;
        case 43:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor* >(); break;
            }
            break;
        case 45:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)()>(_a, &LatexDocument::structureUpdated, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)()>(_a, &LatexDocument::updateCompleter, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)()>(_a, &LatexDocument::updateCompleterCommands, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)()>(_a, &LatexDocument::updateBibTeXFiles, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)(QString )>(_a, &LatexDocument::importPackage, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)(const QString & )>(_a, &LatexDocument::spellingDictChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)()>(_a, &LatexDocument::encodingChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocument::*)(int )>(_a, &LatexDocument::bookmarkLineUpdated, 7))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QFileInfo >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->getFileName(); break;
        case 1: *reinterpret_cast<QFileInfo*>(_v) = _t->getFileInfo(); break;
        case 2: *reinterpret_cast<LatexEditorView**>(_v) = _t->getEditorView(); break;
        default: break;
        }
    }
}

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

void *LatexDocument::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13LatexDocumentE_t>.strings))
        return static_cast<void*>(this);
    return QDocument::qt_metacast(_clname);
}

int LatexDocument::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDocument::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 74)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 74;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 74)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 74;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void LatexDocument::structureUpdated()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

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

// SIGNAL 2
void LatexDocument::updateCompleterCommands()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void LatexDocument::updateBibTeXFiles()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void LatexDocument::importPackage(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void LatexDocument::spellingDictChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void LatexDocument::encodingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void LatexDocument::bookmarkLineUpdated(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN14LatexDocumentsE_t {};
} // unnamed namespace

template <> constexpr inline auto LatexDocuments::qt_create_metaobjectdata<qt_meta_tag_ZN14LatexDocumentsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LatexDocuments",
        "masterDocumentChanged",
        "",
        "LatexDocument*",
        "masterDocument",
        "aboutToDeleteDocument",
        "document",
        "docsToLoad",
        "filenames",
        "QSharedPointer<LatexParser>",
        "lp",
        "docToHide",
        "LatexEditorView*",
        "edView",
        "updateQNFA",
        "bibTeXFilesNeedUpdate",
        "lineGrammarChecked",
        "doc",
        "QDocumentLineHandle*",
        "line",
        "lineNr",
        "QList<GrammarError>",
        "errors",
        "requestedClose",
        "setMasterDocument",
        "getCurrentDocument",
        "getMasterDocument",
        "getDocuments",
        "QList<LatexDocument*>",
        "getRootDocumentForDoc",
        "breakAtSubfileRoot",
        "getCurrentFileName",
        "getCompileFileName",
        "getTemporaryCompileFileName",
        "getLogFileName",
        "getAbsoluteFilePath",
        "relName",
        "extension",
        "additionalSearchPaths",
        "findDocument",
        "fileName",
        "checkTemporaryNames",
        "const QDocument*",
        "qDoc",
        "findDocumentFromName",
        "singleMode",
        "currentDocument",
        "documents"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'masterDocumentChanged'
        QtMocHelpers::SignalData<void(LatexDocument *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'aboutToDeleteDocument'
        QtMocHelpers::SignalData<void(LatexDocument *)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 6 },
        }}),
        // Signal 'docsToLoad'
        QtMocHelpers::SignalData<void(QStringList, QSharedPointer<LatexParser>)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 8 }, { 0x80000000 | 9, 10 },
        }}),
        // Signal 'docToHide'
        QtMocHelpers::SignalData<void(LatexEditorView *)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 },
        }}),
        // Signal 'updateQNFA'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'bibTeXFilesNeedUpdate'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'lineGrammarChecked'
        QtMocHelpers::SlotData<void(LatexDocument *, QDocumentLineHandle *, int, const QList<GrammarError> &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 17 }, { 0x80000000 | 18, 19 }, { QMetaType::Int, 20 }, { 0x80000000 | 21, 22 },
        }}),
        // Slot 'requestedClose'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'setMasterDocument'
        QtMocHelpers::MethodData<void(LatexDocument *)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 6 },
        }}),
        // Method 'getCurrentDocument'
        QtMocHelpers::MethodData<LatexDocument *() const>(25, 2, QMC::AccessPublic, 0x80000000 | 3),
        // Method 'getMasterDocument'
        QtMocHelpers::MethodData<LatexDocument *() const>(26, 2, QMC::AccessPublic, 0x80000000 | 3),
        // Method 'getDocuments'
        QtMocHelpers::MethodData<QList<LatexDocument*>() const>(27, 2, QMC::AccessPublic, 0x80000000 | 28),
        // Method 'getRootDocumentForDoc'
        QtMocHelpers::MethodData<LatexDocument *(LatexDocument *, bool) const>(29, 2, QMC::AccessPublic, 0x80000000 | 3, {{
            { 0x80000000 | 3, 17 }, { QMetaType::Bool, 30 },
        }}),
        // Method 'getRootDocumentForDoc'
        QtMocHelpers::MethodData<LatexDocument *(LatexDocument *) const>(29, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 3, {{
            { 0x80000000 | 3, 17 },
        }}),
        // Method 'getRootDocumentForDoc'
        QtMocHelpers::MethodData<LatexDocument *() const>(29, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 3),
        // Method 'getCurrentFileName'
        QtMocHelpers::MethodData<QString() const>(31, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getCompileFileName'
        QtMocHelpers::MethodData<QString() const>(32, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getTemporaryCompileFileName'
        QtMocHelpers::MethodData<QString() const>(33, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getLogFileName'
        QtMocHelpers::MethodData<QString() const>(34, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &, const QString &, const QStringList &) const>(35, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 36 }, { QMetaType::QString, 37 }, { QMetaType::QStringList, 38 },
        }}),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &, const QString &) const>(35, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 36 }, { QMetaType::QString, 37 },
        }}),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &) const>(35, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 36 },
        }}),
        // Method 'findDocument'
        QtMocHelpers::MethodData<LatexDocument *(const QString &, bool) const>(39, 2, QMC::AccessPublic, 0x80000000 | 3, {{
            { QMetaType::QString, 40 }, { QMetaType::Bool, 41 },
        }}),
        // Method 'findDocument'
        QtMocHelpers::MethodData<LatexDocument *(const QString &) const>(39, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 3, {{
            { QMetaType::QString, 40 },
        }}),
        // Method 'findDocument'
        QtMocHelpers::MethodData<LatexDocument *(const QDocument *) const>(39, 2, QMC::AccessPublic, 0x80000000 | 3, {{
            { 0x80000000 | 42, 43 },
        }}),
        // Method 'findDocumentFromName'
        QtMocHelpers::MethodData<LatexDocument *(const QString &) const>(44, 2, QMC::AccessPublic, 0x80000000 | 3, {{
            { QMetaType::QString, 40 },
        }}),
        // Method 'singleMode'
        QtMocHelpers::MethodData<bool() const>(45, 2, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'currentDocument'
        QtMocHelpers::PropertyData<LatexDocument*>(46, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'masterDocument'
        QtMocHelpers::PropertyData<LatexDocument*>(4, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'documents'
        QtMocHelpers::PropertyData<QList<LatexDocument*>>(47, 0x80000000 | 28, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LatexDocuments, qt_meta_tag_ZN14LatexDocumentsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LatexDocuments::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14LatexDocumentsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14LatexDocumentsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14LatexDocumentsE_t>.metaTypes,
    nullptr
} };

void LatexDocuments::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<LatexDocuments *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->masterDocumentChanged((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 1: _t->aboutToDeleteDocument((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 2: _t->docsToLoad((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSharedPointer<LatexParser>>>(_a[2]))); break;
        case 3: _t->docToHide((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1]))); break;
        case 4: _t->updateQNFA(); break;
        case 5: _t->bibTeXFilesNeedUpdate(); break;
        case 6: _t->lineGrammarChecked((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QList<GrammarError>>>(_a[4]))); break;
        case 7: _t->requestedClose(); break;
        case 8: _t->setMasterDocument((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 9: { LatexDocument* _r = _t->getCurrentDocument();
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 10: { LatexDocument* _r = _t->getMasterDocument();
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 11: { QList<LatexDocument*> _r = _t->getDocuments();
            if (_a[0]) *reinterpret_cast<QList<LatexDocument*>*>(_a[0]) = std::move(_r); }  break;
        case 12: { LatexDocument* _r = _t->getRootDocumentForDoc((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 13: { LatexDocument* _r = _t->getRootDocumentForDoc((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 14: { LatexDocument* _r = _t->getRootDocumentForDoc();
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 15: { QString _r = _t->getCurrentFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 16: { QString _r = _t->getCompileFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 17: { QString _r = _t->getTemporaryCompileFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 18: { QString _r = _t->getLogFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 19: { QString _r = _t->getAbsoluteFilePath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 20: { QString _r = _t->getAbsoluteFilePath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 21: { QString _r = _t->getAbsoluteFilePath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 22: { LatexDocument* _r = _t->findDocument((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 23: { LatexDocument* _r = _t->findDocument((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 24: { LatexDocument* _r = _t->findDocument((*reinterpret_cast<std::add_pointer_t<const QDocument*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 25: { LatexDocument* _r = _t->findDocumentFromName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LatexDocument**>(_a[0]) = std::move(_r); }  break;
        case 26: { bool _r = _t->singleMode();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentLineHandle* >(); break;
            case 3:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<GrammarError> >(); break;
            }
            break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 13:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (LatexDocuments::*)(LatexDocument * )>(_a, &LatexDocuments::masterDocumentChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocuments::*)(LatexDocument * )>(_a, &LatexDocuments::aboutToDeleteDocument, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocuments::*)(QStringList , QSharedPointer<LatexParser> )>(_a, &LatexDocuments::docsToLoad, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocuments::*)(LatexEditorView * )>(_a, &LatexDocuments::docToHide, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (LatexDocuments::*)()>(_a, &LatexDocuments::updateQNFA, 4))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< LatexDocument* >(); break;
        case 2:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<LatexDocument*> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<LatexDocument**>(_v) = _t->getCurrentDocument(); break;
        case 1: *reinterpret_cast<LatexDocument**>(_v) = _t->getMasterDocument(); break;
        case 2: *reinterpret_cast<QList<LatexDocument*>*>(_v) = _t->getDocuments(); break;
        default: break;
        }
    }
}

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

void *LatexDocuments::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14LatexDocumentsE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int LatexDocuments::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 27)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 27;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 27)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 27;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void LatexDocuments::masterDocumentChanged(LatexDocument * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void LatexDocuments::aboutToDeleteDocument(LatexDocument * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void LatexDocuments::docsToLoad(QStringList _t1, QSharedPointer<LatexParser> _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 3
void LatexDocuments::docToHide(LatexEditorView * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void LatexDocuments::updateQNFA()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}
QT_WARNING_POP
