/****************************************************************************
** Meta object code from reading C++ file 'texstudio.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 "../../../texstudio-4.9.3/src/texstudio.h"
#include <QtGui/qtextcursor.h>
#include <QtNetwork/QSslError>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'texstudio.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_ZN9TexstudioE_t {};
} // unnamed namespace

template <> constexpr inline auto Texstudio::qt_create_metaobjectdata<qt_meta_tag_ZN9TexstudioE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Texstudio",
        "infoNewFile",
        "",
        "infoNewFromTemplate",
        "infoLoadFile",
        "filename",
        "infoFileSaved",
        "checkin",
        "infoFileClosed",
        "infoAfterTypeset",
        "imgPreview",
        "fn",
        "load",
        "LatexEditorView*",
        "f",
        "asProject",
        "recheck",
        "dontAsk",
        "executeCommandLine",
        "args",
        "realCmdLine",
        "startupCompleted",
        "onOtherInstanceMessage",
        "fuzzCursorHistory",
        "fuzzBackForward",
        "setBuildButtonsDisabled",
        "c",
        "updateToolBarMenu",
        "menuName",
        "showTestProgress",
        "message",
        "leftPanelChanged",
        "QWidget*",
        "widget",
        "updateTOCs",
        "updateAllTOCs",
        "updateTOC",
        "updateCurrentPosInTOC",
        "StructureEntry*",
        "old",
        "selected",
        "updateCurrentPosInStructure",
        "updateCurrentPosInTOCHelper",
        "QTreeWidgetItem*",
        "root",
        "tocMode",
        "syncExpanded",
        "item",
        "syncCollapsed",
        "editSectionCopy",
        "editSectionCut",
        "editSectionPasteAfter",
        "editSectionPasteBefore",
        "editIndentSection",
        "editUnIndentSection",
        "gotoLineFromAction",
        "openAllRelatedDocuments",
        "closeAllRelatedDocuments",
        "toggleMasterDocument",
        "closeDocument",
        "copyFileName",
        "copyFilePath",
        "showInGraphicalShell_",
        "toggleSingleDocMode",
        "expandSubitems",
        "collapseSubitems",
        "labelForStructureEntry",
        "const StructureEntry*",
        "entry",
        "updateStructureLocally",
        "updateAll",
        "customMenuStructure",
        "QPoint",
        "pos",
        "createLabelFromAction",
        "relayToEditorSlot",
        "relayToOwnSlot",
        "autoRunScripts",
        "runScripts",
        "trigger",
        "runScriptsInList",
        "QList<Macro>",
        "scripts",
        "fileNew",
        "fileName",
        "fileNewFromTemplate",
        "fileMakeTemplate",
        "fileOpen",
        "currentDir",
        "fileRestoreSession",
        "showProgress",
        "warnMissing",
        "fileSave",
        "saveSilently",
        "QEditor*",
        "editor",
        "fileSaveAll",
        "fileSaveAllFromTimer",
        "alsoUnnamedFiles",
        "alwaysCurrentFile",
        "fileSaveAs",
        "fileNewInternal",
        "fileUtilCopyMove",
        "move",
        "fileUtilDelete",
        "fileUtilRevert",
        "fileUtilPermissions",
        "fileUtilCopyFileName",
        "fileUtilCopyMasterFileName",
        "fileClose",
        "fileCloseAll",
        "fileExit",
        "fileExitWithError",
        "fileOpenRecent",
        "fileOpenAllRecent",
        "fileRecentList",
        "fileClearRecentList",
        "fileRemoveFromRecentList",
        "viewDocumentListHidden",
        "fileDocumentOpenFromChoosen",
        "doc",
        "duplicate",
        "lineNr",
        "column",
        "viewDocumentList",
        "viewDocumentOpenFromChoosen",
        "fileOpenFirstNonOpen",
        "fileOpenRecentProject",
        "fileLoadSession",
        "loadSession",
        "fileSaveSession",
        "restoreSession",
        "Session",
        "s",
        "getCurrentSession",
        "MarkCurrentFileAsRecent",
        "fileCheckin",
        "fileLockPdf",
        "fileCheckinPdf",
        "fileUpdate",
        "fileUpdateCWD",
        "checkinAfterSave",
        "checkIn",
        "text",
        "push",
        "svnadd",
        "stage",
        "svnUndo",
        "redo",
        "svnPatch",
        "ed",
        "diff",
        "showOldRevisions",
        "changeToRevision",
        "rev",
        "old_rev",
        "svnDialogClosed",
        "fileDiff",
        "fileDiff3",
        "checkSVNConflicted",
        "substituteContents",
        "removeDiffMarkers",
        "theirs",
        "editChangeDiff",
        "pt",
        "jumpNextDiff",
        "jumpPrevDiff",
        "fileDiffMerge",
        "declareConflictResolved",
        "openExternalFile",
        "name",
        "defaultExt",
        "LatexDocument*",
        "relativeToCurrentDoc",
        "openExternalFileFromAction",
        "editUndo",
        "editRedo",
        "editDebugUndoStack",
        "editCopy",
        "editPaste",
        "editPasteImage",
        "QImage",
        "image",
        "editTextToLowercase",
        "editTextToUppercase",
        "editTextToTitlecase",
        "smart",
        "editTextToTitlecaseSmart",
        "editFind",
        "editPasteLatex",
        "convertToLatex",
        "editHardLineBreak",
        "editHardLineBreakRepeat",
        "editDeleteLine",
        "editCutLine",
        "editDeleteToEndOfLine",
        "editDeleteFromStartOfLine",
        "editMoveLineUp",
        "editMoveLineDown",
        "editDuplicateLine",
        "editSortLines",
        "editAlignMirrors",
        "editEraseWordCmdEnv",
        "editGotoDefinition",
        "QDocumentCursor",
        "editSpell",
        "editThesaurus",
        "line",
        "col",
        "editChangeLineEnding",
        "setPreviewMode",
        "editSetupEncoding",
        "editInsertUnicode",
        "editInsertRefToNextLabel",
        "refCmd",
        "backward",
        "editInsertRefToPrevLabel",
        "runSearch",
        "SearchQuery*",
        "query",
        "findLabelUsages",
        "labelText",
        "findSpecialUsages",
        "type",
        "findLabelUsagesFromAction",
        "searchResultWidget",
        "SearchResultWidget*",
        "findWordRepetions",
        "findNextWordRepetion",
        "LTErrorMessage",
        "paletteChanged",
        "QPalette",
        "palette",
        "colorSchemeChanged",
        "Qt::ColorScheme",
        "colorScheme",
        "readSettings",
        "reread",
        "saveSettings",
        "configName",
        "restoreDefaultSettings",
        "showSettings",
        "showMarkTooltipForLogMessage",
        "QList<int>",
        "errors",
        "newDocumentLineEnding",
        "updateCaption",
        "updateMasterDocumentCaption",
        "updateUndoRedoStatus",
        "currentEditorChanged",
        "editorTabMoved",
        "from",
        "to",
        "editorAboutToChangeByTabClick",
        "edFrom",
        "edTo",
        "updateStructure",
        "initial",
        "hidden",
        "structureContextMenuToggleMasterDocument",
        "document",
        "editRemovePlaceHolders",
        "editRemoveCurrentPlaceHolder",
        "normalCompletion",
        "insertEnvironmentCompletion",
        "insertTextCompletion",
        "insertText",
        "insertTag",
        "Entity",
        "dx",
        "dy",
        "insertCitation",
        "insertFormula",
        "formula",
        "insertSymbol",
        "insertXmlTag",
        "QListWidgetItem*",
        "insertXmlTagFromToolButtonAction",
        "callToolButtonAction",
        "insertFromAction",
        "insertTextFromAction",
        "insertFromTagList",
        "insertBib",
        "openFromExplorer",
        "QModelIndex",
        "index",
        "insertFromExplorer",
        "visible",
        "closeEnvironment",
        "insertBibEntryFromAction",
        "insertBibEntry",
        "id",
        "setBibTypeFromAction",
        "insertUserTag",
        "execMacro",
        "Macro",
        "m",
        "MacroExecContext",
        "context",
        "allowWrite",
        "runScript",
        "script",
        "editMacros",
        "macroDialogAccepted",
        "macroDialogRejected",
        "insertRef",
        "insertEqRef",
        "insertPageRef",
        "changeTextCodec",
        "updateAvailableLanguages",
        "updateLanguageToolStatus",
        "editorSpellerChanged",
        "changeEditorSpeller",
        "showMoreDictionaries",
        "insertSpellcheckMagicComment",
        "updateStatusBarEncoding",
        "addMagicRoot",
        "addMagicCoding",
        "addMagicBibliography",
        "addMagicProgram",
        "quickTabular",
        "const QMimeData*",
        "d",
        "quickArray",
        "quickTabbing",
        "quickLetter",
        "quickDocument",
        "quickBeamer",
        "quickGraphics",
        "graphicsFile",
        "quickMath",
        "aiChat",
        "queryText",
        "checkProgramPermission",
        "program",
        "cmdId",
        "master",
        "runInternalPdfViewer",
        "QFileInfo",
        "options",
        "runBibliographyIfNecessary",
        "cmd",
        "GetBblLastModified",
        "showExtendedSearch",
        "changeIconSize",
        "value",
        "changeSecondaryIconSize",
        "changePDFIconSize",
        "changeSymbolGridIconSize",
        "changePanel",
        "connectSubCommand",
        "ProcessX*",
        "p",
        "showStdoutLocallyDefault",
        "runInternalCommand",
        "commandLineRequested",
        "QString*",
        "result",
        "bool*",
        "beginRunningCommand",
        "commandMain",
        "latex",
        "pdf",
        "async",
        "beginRunningSubCommand",
        "subCommand",
        "RunCommandFlags",
        "flags",
        "endRunningSubCommand",
        "endRunningCommand",
        "runCommand",
        "commandline",
        "buffer",
        "QTextCodec*",
        "codecForBuffer",
        "saveAll",
        "runCommandNoSpecialChars",
        "setStatusMessageProcess",
        "runCommandAsync",
        "const char*",
        "returnCMD",
        "processNotification",
        "clearLogs",
        "openExternalTerminal",
        "cleanAll",
        "commandFromAction",
        "webPublish",
        "webPublishSource",
        "convertToPlainText",
        "analyseText",
        "analyseTextFormDestroyed",
        "generateRandomText",
        "startCollabServer",
        "connectCollabServer",
        "disconnectCollabServer",
        "updateCollabCursors",
        "cur",
        "userId",
        "removeCollabCursor",
        "removeAllCollabCursor",
        "updateCollabChanges",
        "changes",
        "userName",
        "updateCollaborationEditors",
        "startLine",
        "startCol",
        "endLine",
        "endCol",
        "registerFileForCollab",
        "collabClientFinished",
        "exitCode",
        "m_errorMessage",
        "guestServerSuccessfullyStarted",
        "hostServerSuccessfullyStarted",
        "updateCollabStatus",
        "copyCollabLinkToClipboard",
        "loadLog",
        "onCompileError",
        "setLogMarksVisible",
        "clearLogEntriesInEditors",
        "updateLogEntriesInEditors",
        "showLog",
        "viewLog",
        "viewLogOrReRun",
        "LatexCompileResult*",
        "gotoNearLogEntry",
        "lt",
        "notFoundMessage",
        "hasLatexErrors",
        "logExists",
        "clearMarkers",
        "latexHelp",
        "userManualHelp",
        "texdocHelp",
        "helpAbout",
        "generalOptions",
        "setAutomaticRootDetection",
        "setExplicitRootDocument",
        "setCurrentDocAsExplicitRoot",
        "gotoNextDocument",
        "gotoPrevDocument",
        "gotoOpenDocument",
        "updateOpenDocumentMenu",
        "localChange",
        "onEditorsReordered",
        "focusEditor",
        "focusViewer",
        "enlargeEmbeddedPDFViewer",
        "shrinkEmbeddedPDFViewer",
        "preserveConfig",
        "setEnabledMenusEnlargeShrink",
        "enabledEnlarge",
        "enabledShrink",
        "showStatusbar",
        "viewCloseElement",
        "setFullScreenMode",
        "viewSetHighlighting",
        "QAction*",
        "act",
        "showHighlightingMenu",
        "viewCollapseBlock",
        "viewExpandBlock",
        "newPdfPreviewer",
        "embedded",
        "pdfClosed",
        "masterDocumentChanged",
        "aboutToDeleteDocument",
        "updateCompleter",
        "edView",
        "completerNeedsUpdate",
        "completerCommandsNeedsUpdate",
        "needUpdatedCompleter",
        "outputPageChanged",
        "gotoLine",
        "QEditor::MoveFlags",
        "mflags",
        "setFocus",
        "gotoLogEntryEditorOnly",
        "logEntryNumber",
        "getLogEntryContextCursor",
        "const QDocumentLineHandle*",
        "dlh",
        "LatexLogEntry",
        "gotoLogEntryAt",
        "newLineNumber",
        "gotoMark",
        "findOccurencesApproximate",
        "checkLine",
        "guessedWord",
        "syncFromViewer",
        "activate",
        "goBack",
        "goForward",
        "setGlobalCursor",
        "saveCurrentCursorToHistory",
        "saveEditorCursorToHistory",
        "previewLatex",
        "previewAvailable",
        "imageFile",
        "PreviewSource",
        "source",
        "clearPreview",
        "showPreview",
        "addToList",
        "makePreviewHeader",
        "const LatexDocument*",
        "rootDoc",
        "showPreviewQueue",
        "showImgPreview",
        "fname",
        "showImgPreviewFinished",
        "QPixmap",
        "pm",
        "page",
        "recompileForPreview",
        "recompileForPreviewNow",
        "templateEdit",
        "fileReloaded",
        "fileInConflictShowDiff",
        "fileAutoReloading",
        "jumpToSearchResult",
        "lineNumber",
        "const SearchQuery*",
        "jumpToFileSearchResult",
        "cursorPositionChanged",
        "syncPDFViewer",
        "inForeground",
        "generateMirror",
        "setCur",
        "generateBracketInverterMirror",
        "jumpToBracket",
        "selectBracket",
        "findMissingBracket",
        "cursorHovered",
        "loadProfile",
        "saveProfile",
        "addRowCB",
        "addColumnCB",
        "removeColumnCB",
        "removeRowCB",
        "cutColumnCB",
        "pasteColumnCB",
        "addHLineCB",
        "remHLineCB",
        "insertTableTemplate",
        "alignTableCols",
        "updateTexQNFA",
        "updateTexLikeQNFA",
        "languageName",
        "toggleGrammar",
        "openInternalDocViewer",
        "package",
        "command",
        "importPackage",
        "packageScanCompleted",
        "stopPackageParser",
        "packageParserFinished",
        "readinAllPackageNames",
        "packageListReadCompleted",
        "std::set<QString>",
        "packages",
        "threadCrashed",
        "iamalive",
        "checkLatexInstall",
        "checkCWLs",
        "checkLanguageTool",
        "slowOperationStarted",
        "slowOperationEnded",
        "openBugsAndFeatures",
        "maniplateDockingTabBars",
        "addDock",
        "iconName",
        "title",
        "wgt",
        "toggleDocks",
        "resetDocks",
        "toggleDockVisibility",
        "updateDockVisibility",
        "checkDockSpread",
        "getCurrentFileName",
        "getAbsoluteFilePath",
        "relName",
        "extension",
        "getRelativeFileName",
        "file",
        "basepath",
        "keepSuffix",
        "fileExists",
        "newManagedMenu",
        "QMenu*",
        "menu",
        "newManagedAction",
        "slotName",
        "QKeySequence",
        "shortCut",
        "iconFile",
        "QList<QVariant>",
        "QList<QKeySequence>",
        "shortCuts",
        "newManagedEditorAction",
        "getManagedMenu",
        "getManagedAction",
        "getManagedActions",
        "QList<QAction*>",
        "ids",
        "commonPrefix",
        "insertManagedAction",
        "before",
        "loadManagedMenu",
        "setupToolBars",
        "completerIsVisible",
        "currentEditorView",
        "currentEditor",
        "clipboardText",
        "QClipboard::Mode",
        "mode",
        "setClipboardText",
        "getVersion",
        "simulateKeyPress",
        "shortcut",
        "clipboard"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'infoNewFile'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'infoNewFromTemplate'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'infoLoadFile'
        QtMocHelpers::SignalData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'infoFileSaved'
        QtMocHelpers::SignalData<void(const QString &, const int)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::Int, 7 },
        }}),
        // Signal 'infoFileSaved'
        QtMocHelpers::SignalData<void(const QString &)>(6, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'infoFileClosed'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'infoAfterTypeset'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'imgPreview'
        QtMocHelpers::SignalData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<LatexEditorView *(const QString &, bool, bool, bool)>(12, 2, QMC::AccessPublic, 0x80000000 | 13, {{
            { QMetaType::QString, 14 }, { QMetaType::Bool, 15 }, { QMetaType::Bool, 16 }, { QMetaType::Bool, 17 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<LatexEditorView *(const QString &, bool, bool)>(12, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 13, {{
            { QMetaType::QString, 14 }, { QMetaType::Bool, 15 }, { QMetaType::Bool, 16 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<LatexEditorView *(const QString &, bool)>(12, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 13, {{
            { QMetaType::QString, 14 }, { QMetaType::Bool, 15 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<LatexEditorView *(const QString &)>(12, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 13, {{
            { QMetaType::QString, 14 },
        }}),
        // Slot 'executeCommandLine'
        QtMocHelpers::SlotData<void(const QStringList &, bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 19 }, { QMetaType::Bool, 20 },
        }}),
        // Slot 'startupCompleted'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onOtherInstanceMessage'
        QtMocHelpers::SlotData<void(const QString &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'fuzzCursorHistory'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'fuzzBackForward'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setBuildButtonsDisabled'
        QtMocHelpers::SlotData<void(bool)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 26 },
        }}),
        // Slot 'updateToolBarMenu'
        QtMocHelpers::SlotData<void(const QString &)>(27, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 28 },
        }}),
        // Slot 'showTestProgress'
        QtMocHelpers::SlotData<void(const QString &)>(29, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Slot 'leftPanelChanged'
        QtMocHelpers::SlotData<void(QWidget *)>(31, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 32, 33 },
        }}),
        // Slot 'updateTOCs'
        QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateAllTOCs'
        QtMocHelpers::SlotData<void()>(35, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateTOC'
        QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateCurrentPosInTOC'
        QtMocHelpers::SlotData<void(StructureEntry *, StructureEntry *)>(37, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 38, 39 }, { 0x80000000 | 38, 40 },
        }}),
        // Slot 'updateCurrentPosInTOC'
        QtMocHelpers::SlotData<void(StructureEntry *)>(37, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 38, 39 },
        }}),
        // Slot 'updateCurrentPosInTOC'
        QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'updateCurrentPosInStructure'
        QtMocHelpers::SlotData<void(StructureEntry *, StructureEntry *)>(41, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 38, 39 }, { 0x80000000 | 38, 40 },
        }}),
        // Slot 'updateCurrentPosInStructure'
        QtMocHelpers::SlotData<void(StructureEntry *)>(41, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 38, 39 },
        }}),
        // Slot 'updateCurrentPosInStructure'
        QtMocHelpers::SlotData<void()>(41, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'updateCurrentPosInTOCHelper'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, StructureEntry *, StructureEntry *, bool)>(42, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 44 }, { 0x80000000 | 38, 39 }, { 0x80000000 | 38, 40 }, { QMetaType::Bool, 45 },
        }}),
        // Slot 'updateCurrentPosInTOCHelper'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, StructureEntry *, StructureEntry *)>(42, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 43, 44 }, { 0x80000000 | 38, 39 }, { 0x80000000 | 38, 40 },
        }}),
        // Slot 'updateCurrentPosInTOCHelper'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, StructureEntry *)>(42, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 43, 44 }, { 0x80000000 | 38, 39 },
        }}),
        // Slot 'updateCurrentPosInTOCHelper'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *)>(42, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Slot 'updateCurrentPosInTOCHelper'
        QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'syncExpanded'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *)>(46, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 47 },
        }}),
        // Slot 'syncCollapsed'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *)>(48, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 47 },
        }}),
        // Slot 'editSectionCopy'
        QtMocHelpers::SlotData<void()>(49, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editSectionCut'
        QtMocHelpers::SlotData<void()>(50, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editSectionPasteAfter'
        QtMocHelpers::SlotData<void()>(51, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editSectionPasteBefore'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editIndentSection'
        QtMocHelpers::SlotData<void()>(53, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editUnIndentSection'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoLineFromAction'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openAllRelatedDocuments'
        QtMocHelpers::SlotData<void()>(56, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'closeAllRelatedDocuments'
        QtMocHelpers::SlotData<void()>(57, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'toggleMasterDocument'
        QtMocHelpers::SlotData<void()>(58, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'closeDocument'
        QtMocHelpers::SlotData<void()>(59, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'copyFileName'
        QtMocHelpers::SlotData<void()>(60, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'copyFilePath'
        QtMocHelpers::SlotData<void()>(61, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'showInGraphicalShell_'
        QtMocHelpers::SlotData<void()>(62, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'toggleSingleDocMode'
        QtMocHelpers::SlotData<void()>(63, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'expandSubitems'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'collapseSubitems'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'labelForStructureEntry'
        QtMocHelpers::SlotData<StructureEntry *(const StructureEntry *)>(66, 2, QMC::AccessPrivate, 0x80000000 | 38, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Slot 'updateStructureLocally'
        QtMocHelpers::SlotData<void(bool)>(69, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 70 },
        }}),
        // Slot 'updateStructureLocally'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'customMenuStructure'
        QtMocHelpers::SlotData<void(const QPoint &)>(71, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 72, 73 },
        }}),
        // Slot 'createLabelFromAction'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'relayToEditorSlot'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'relayToOwnSlot'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'autoRunScripts'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'runScripts'
        QtMocHelpers::SlotData<void(int)>(78, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 79 },
        }}),
        // Slot 'runScriptsInList'
        QtMocHelpers::SlotData<void(int, const QList<Macro> &)>(80, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 79 }, { 0x80000000 | 81, 82 },
        }}),
        // Slot 'fileNew'
        QtMocHelpers::SlotData<void(QString)>(83, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 84 },
        }}),
        // Slot 'fileNew'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileNewFromTemplate'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileMakeTemplate'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileOpen'
        QtMocHelpers::SlotData<void(QString)>(87, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 88 },
        }}),
        // Slot 'fileOpen'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileRestoreSession'
        QtMocHelpers::SlotData<void(bool, bool)>(89, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 90 }, { QMetaType::Bool, 91 },
        }}),
        // Slot 'fileRestoreSession'
        QtMocHelpers::SlotData<void(bool)>(89, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 90 },
        }}),
        // Slot 'fileRestoreSession'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileSave'
        QtMocHelpers::SlotData<void(const bool, QEditor *)>(92, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 93 }, { 0x80000000 | 94, 95 },
        }}),
        // Slot 'fileSave'
        QtMocHelpers::SlotData<void(const bool)>(92, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 93 },
        }}),
        // Slot 'fileSave'
        QtMocHelpers::SlotData<void()>(92, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileSaveAll'
        QtMocHelpers::SlotData<void()>(96, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileSaveAllFromTimer'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileSaveAll'
        QtMocHelpers::SlotData<void(bool, bool)>(96, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 98 }, { QMetaType::Bool, 99 },
        }}),
        // Slot 'fileSaveAs'
        QtMocHelpers::SlotData<void(const QString &)>(100, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 84 },
        }}),
        // Slot 'fileSaveAs'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileSaveAs'
        QtMocHelpers::SlotData<void(const QString &, const bool)>(100, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 84 }, { QMetaType::Bool, 93 },
        }}),
        // Slot 'fileNewInternal'
        QtMocHelpers::SlotData<void(QString)>(101, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 84 },
        }}),
        // Slot 'fileNewInternal'
        QtMocHelpers::SlotData<void()>(101, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileUtilCopyMove'
        QtMocHelpers::SlotData<void(bool)>(102, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 103 },
        }}),
        // Slot 'fileUtilDelete'
        QtMocHelpers::SlotData<void()>(104, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileUtilRevert'
        QtMocHelpers::SlotData<void()>(105, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileUtilPermissions'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileUtilCopyFileName'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileUtilCopyMasterFileName'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileClose'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileCloseAll'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileExit'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileExitWithError'
        QtMocHelpers::SlotData<void()>(112, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileOpenRecent'
        QtMocHelpers::SlotData<void()>(113, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileOpenAllRecent'
        QtMocHelpers::SlotData<void()>(114, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileRecentList'
        QtMocHelpers::SlotData<void()>(115, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileClearRecentList'
        QtMocHelpers::SlotData<void()>(116, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileRemoveFromRecentList'
        QtMocHelpers::SlotData<void(const QString &)>(117, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'viewDocumentListHidden'
        QtMocHelpers::SlotData<void()>(118, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileDocumentOpenFromChoosen'
        QtMocHelpers::SlotData<void(const QString &, int, int, int)>(119, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 120 }, { QMetaType::Int, 121 }, { QMetaType::Int, 122 }, { QMetaType::Int, 123 },
        }}),
        // Slot 'viewDocumentList'
        QtMocHelpers::SlotData<void()>(124, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewDocumentOpenFromChoosen'
        QtMocHelpers::SlotData<void(const QString &, int, int, int)>(125, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 120 }, { QMetaType::Int, 121 }, { QMetaType::Int, 122 }, { QMetaType::Int, 123 },
        }}),
        // Slot 'fileOpenFirstNonOpen'
        QtMocHelpers::SlotData<void()>(126, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileOpenRecentProject'
        QtMocHelpers::SlotData<void()>(127, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileLoadSession'
        QtMocHelpers::SlotData<void()>(128, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'loadSession'
        QtMocHelpers::SlotData<void(const QString &)>(129, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 84 },
        }}),
        // Slot 'fileSaveSession'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'restoreSession'
        QtMocHelpers::SlotData<void(const Session &, bool, bool)>(131, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 132, 133 }, { QMetaType::Bool, 90 }, { QMetaType::Bool, 91 },
        }}),
        // Slot 'restoreSession'
        QtMocHelpers::SlotData<void(const Session &, bool)>(131, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 132, 133 }, { QMetaType::Bool, 90 },
        }}),
        // Slot 'restoreSession'
        QtMocHelpers::SlotData<void(const Session &)>(131, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 132, 133 },
        }}),
        // Slot 'getCurrentSession'
        QtMocHelpers::SlotData<Session()>(134, 2, QMC::AccessPrivate, 0x80000000 | 132),
        // Slot 'MarkCurrentFileAsRecent'
        QtMocHelpers::SlotData<void()>(135, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileCheckin'
        QtMocHelpers::SlotData<void(QString)>(136, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'fileCheckin'
        QtMocHelpers::SlotData<void()>(136, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileLockPdf'
        QtMocHelpers::SlotData<void(QString)>(137, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'fileLockPdf'
        QtMocHelpers::SlotData<void()>(137, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileCheckinPdf'
        QtMocHelpers::SlotData<void(QString)>(138, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'fileCheckinPdf'
        QtMocHelpers::SlotData<void()>(138, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileUpdate'
        QtMocHelpers::SlotData<void(QString)>(139, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'fileUpdate'
        QtMocHelpers::SlotData<void()>(139, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'fileUpdateCWD'
        QtMocHelpers::SlotData<void(QString)>(140, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'fileUpdateCWD'
        QtMocHelpers::SlotData<void()>(140, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'checkinAfterSave'
        QtMocHelpers::SlotData<void(QString, int)>(141, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::Int, 142 },
        }}),
        // Slot 'checkinAfterSave'
        QtMocHelpers::SlotData<void(QString)>(141, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'checkin'
        QtMocHelpers::SlotData<void(QString, QString, bool)>(7, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { QMetaType::QString, 143 }, { QMetaType::Bool, 144 },
        }}),
        // Slot 'checkin'
        QtMocHelpers::SlotData<void(QString, QString)>(7, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { QMetaType::QString, 143 },
        }}),
        // Slot 'checkin'
        QtMocHelpers::SlotData<void(QString)>(7, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'svnadd'
        QtMocHelpers::SlotData<bool(QString, int)>(145, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { QMetaType::QString, 11 }, { QMetaType::Int, 146 },
        }}),
        // Slot 'svnadd'
        QtMocHelpers::SlotData<bool(QString)>(145, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'svnUndo'
        QtMocHelpers::SlotData<void(bool)>(147, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 148 },
        }}),
        // Slot 'svnUndo'
        QtMocHelpers::SlotData<void()>(147, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'svnPatch'
        QtMocHelpers::SlotData<void(QEditor *, QString)>(149, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 94, 150 }, { QMetaType::QString, 151 },
        }}),
        // Slot 'showOldRevisions'
        QtMocHelpers::SlotData<void()>(152, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'changeToRevision'
        QtMocHelpers::SlotData<void(QString, QString)>(153, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 154 }, { QMetaType::QString, 155 },
        }}),
        // Slot 'changeToRevision'
        QtMocHelpers::SlotData<void(QString)>(153, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 154 },
        }}),
        // Slot 'svnDialogClosed'
        QtMocHelpers::SlotData<void(int)>(156, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Slot 'fileDiff'
        QtMocHelpers::SlotData<void()>(157, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'fileDiff3'
        QtMocHelpers::SlotData<void()>(158, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'checkSVNConflicted'
        QtMocHelpers::SlotData<bool(bool)>(159, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { QMetaType::Bool, 160 },
        }}),
        // Slot 'checkSVNConflicted'
        QtMocHelpers::SlotData<bool()>(159, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'removeDiffMarkers'
        QtMocHelpers::SlotData<void(bool)>(161, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 162 },
        }}),
        // Slot 'removeDiffMarkers'
        QtMocHelpers::SlotData<void()>(161, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'editChangeDiff'
        QtMocHelpers::SlotData<void(QPoint)>(163, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 72, 164 },
        }}),
        // Slot 'jumpNextDiff'
        QtMocHelpers::SlotData<void()>(165, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'jumpPrevDiff'
        QtMocHelpers::SlotData<void()>(166, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'fileDiffMerge'
        QtMocHelpers::SlotData<void()>(167, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'declareConflictResolved'
        QtMocHelpers::SlotData<void()>(168, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openExternalFile'
        QtMocHelpers::SlotData<LatexEditorView *(QString, const QString &, LatexDocument *, bool)>(169, 2, QMC::AccessProtected, 0x80000000 | 13, {{
            { QMetaType::QString, 170 }, { QMetaType::QString, 171 }, { 0x80000000 | 172, 120 }, { QMetaType::Bool, 173 },
        }}),
        // Slot 'openExternalFile'
        QtMocHelpers::SlotData<LatexEditorView *(QString, const QString &, LatexDocument *)>(169, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 13, {{
            { QMetaType::QString, 170 }, { QMetaType::QString, 171 }, { 0x80000000 | 172, 120 },
        }}),
        // Slot 'openExternalFile'
        QtMocHelpers::SlotData<LatexEditorView *(QString, const QString &)>(169, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 13, {{
            { QMetaType::QString, 170 }, { QMetaType::QString, 171 },
        }}),
        // Slot 'openExternalFile'
        QtMocHelpers::SlotData<LatexEditorView *(QString)>(169, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 13, {{
            { QMetaType::QString, 170 },
        }}),
        // Slot 'openExternalFileFromAction'
        QtMocHelpers::SlotData<void()>(174, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editUndo'
        QtMocHelpers::SlotData<void()>(175, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editRedo'
        QtMocHelpers::SlotData<void()>(176, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editDebugUndoStack'
        QtMocHelpers::SlotData<void()>(177, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editCopy'
        QtMocHelpers::SlotData<void()>(178, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editPaste'
        QtMocHelpers::SlotData<void()>(179, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editPasteImage'
        QtMocHelpers::SlotData<void(QImage)>(180, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 181, 182 },
        }}),
        // Slot 'editTextToLowercase'
        QtMocHelpers::SlotData<void()>(183, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editTextToUppercase'
        QtMocHelpers::SlotData<void()>(184, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editTextToTitlecase'
        QtMocHelpers::SlotData<void(bool)>(185, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 186 },
        }}),
        // Slot 'editTextToTitlecase'
        QtMocHelpers::SlotData<void()>(185, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'editTextToTitlecaseSmart'
        QtMocHelpers::SlotData<void()>(187, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editFind'
        QtMocHelpers::SlotData<void()>(188, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editPasteLatex'
        QtMocHelpers::SlotData<void()>(189, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'convertToLatex'
        QtMocHelpers::SlotData<void()>(190, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editHardLineBreak'
        QtMocHelpers::SlotData<void()>(191, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editHardLineBreakRepeat'
        QtMocHelpers::SlotData<void()>(192, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editDeleteLine'
        QtMocHelpers::SlotData<void()>(193, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editCutLine'
        QtMocHelpers::SlotData<void()>(194, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editDeleteToEndOfLine'
        QtMocHelpers::SlotData<void()>(195, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editDeleteFromStartOfLine'
        QtMocHelpers::SlotData<void()>(196, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editMoveLineUp'
        QtMocHelpers::SlotData<void()>(197, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editMoveLineDown'
        QtMocHelpers::SlotData<void()>(198, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editDuplicateLine'
        QtMocHelpers::SlotData<void()>(199, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editSortLines'
        QtMocHelpers::SlotData<void()>(200, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editAlignMirrors'
        QtMocHelpers::SlotData<void()>(201, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editEraseWordCmdEnv'
        QtMocHelpers::SlotData<void()>(202, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editGotoDefinition'
        QtMocHelpers::SlotData<void(QDocumentCursor)>(203, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 26 },
        }}),
        // Slot 'editGotoDefinition'
        QtMocHelpers::SlotData<void()>(203, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'editSpell'
        QtMocHelpers::SlotData<void()>(205, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editThesaurus'
        QtMocHelpers::SlotData<void(int, int)>(206, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 207 }, { QMetaType::Int, 208 },
        }}),
        // Slot 'editThesaurus'
        QtMocHelpers::SlotData<void(int)>(206, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 207 },
        }}),
        // Slot 'editThesaurus'
        QtMocHelpers::SlotData<void()>(206, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'editChangeLineEnding'
        QtMocHelpers::SlotData<void()>(209, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setPreviewMode'
        QtMocHelpers::SlotData<void()>(210, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editSetupEncoding'
        QtMocHelpers::SlotData<void()>(211, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editInsertUnicode'
        QtMocHelpers::SlotData<void()>(212, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editInsertRefToNextLabel'
        QtMocHelpers::SlotData<void(const QString &, bool)>(213, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 214 }, { QMetaType::Bool, 215 },
        }}),
        // Slot 'editInsertRefToNextLabel'
        QtMocHelpers::SlotData<void(const QString &)>(213, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 214 },
        }}),
        // Slot 'editInsertRefToNextLabel'
        QtMocHelpers::SlotData<void()>(213, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'editInsertRefToPrevLabel'
        QtMocHelpers::SlotData<void(const QString &)>(216, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 214 },
        }}),
        // Slot 'editInsertRefToPrevLabel'
        QtMocHelpers::SlotData<void()>(216, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'runSearch'
        QtMocHelpers::SlotData<void(SearchQuery *)>(217, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 218, 219 },
        }}),
        // Slot 'findLabelUsages'
        QtMocHelpers::SlotData<void(LatexDocument *, const QString &)>(220, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 }, { QMetaType::QString, 221 },
        }}),
        // Slot 'findSpecialUsages'
        QtMocHelpers::SlotData<void(LatexDocument *, const QString &, int)>(222, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 }, { QMetaType::QString, 143 }, { QMetaType::Int, 223 },
        }}),
        // Slot 'findLabelUsagesFromAction'
        QtMocHelpers::SlotData<void()>(224, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'searchResultWidget'
        QtMocHelpers::SlotData<SearchResultWidget *()>(225, 2, QMC::AccessProtected, 0x80000000 | 226),
        // Slot 'findWordRepetions'
        QtMocHelpers::SlotData<void()>(227, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'findNextWordRepetion'
        QtMocHelpers::SlotData<void()>(228, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'LTErrorMessage'
        QtMocHelpers::SlotData<void(QString)>(229, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Slot 'paletteChanged'
        QtMocHelpers::SlotData<void(const QPalette &)>(230, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 231, 232 },
        }}),
        // Slot 'colorSchemeChanged'
        QtMocHelpers::SlotData<void(Qt::ColorScheme)>(233, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 234, 235 },
        }}),
        // Slot 'readSettings'
        QtMocHelpers::SlotData<void(bool)>(236, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 237 },
        }}),
        // Slot 'readSettings'
        QtMocHelpers::SlotData<void()>(236, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'saveSettings'
        QtMocHelpers::SlotData<void(const QString &)>(238, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 239 },
        }}),
        // Slot 'saveSettings'
        QtMocHelpers::SlotData<void()>(238, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void),
        // Slot 'restoreDefaultSettings'
        QtMocHelpers::SlotData<void()>(240, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'showSettings'
        QtMocHelpers::SlotData<void()>(241, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'showMarkTooltipForLogMessage'
        QtMocHelpers::SlotData<void(QList<int>)>(242, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 243, 244 },
        }}),
        // Slot 'newDocumentLineEnding'
        QtMocHelpers::SlotData<void()>(245, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateCaption'
        QtMocHelpers::SlotData<void()>(246, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateMasterDocumentCaption'
        QtMocHelpers::SlotData<void()>(247, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateUndoRedoStatus'
        QtMocHelpers::SlotData<void()>(248, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'currentEditorChanged'
        QtMocHelpers::SlotData<void()>(249, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editorTabMoved'
        QtMocHelpers::SlotData<void(int, int)>(250, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 251 }, { QMetaType::Int, 252 },
        }}),
        // Slot 'editorAboutToChangeByTabClick'
        QtMocHelpers::SlotData<void(LatexEditorView *, LatexEditorView *)>(253, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 13, 254 }, { 0x80000000 | 13, 255 },
        }}),
        // Slot 'updateStructure'
        QtMocHelpers::SlotData<void(bool, LatexDocument *, bool)>(256, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 257 }, { 0x80000000 | 172, 120 }, { QMetaType::Bool, 258 },
        }}),
        // Slot 'updateStructure'
        QtMocHelpers::SlotData<void(bool, LatexDocument *)>(256, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 257 }, { 0x80000000 | 172, 120 },
        }}),
        // Slot 'updateStructure'
        QtMocHelpers::SlotData<void(bool)>(256, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 257 },
        }}),
        // Slot 'updateStructure'
        QtMocHelpers::SlotData<void()>(256, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'structureContextMenuToggleMasterDocument'
        QtMocHelpers::SlotData<void(LatexDocument *)>(259, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 260 },
        }}),
        // Slot 'editRemovePlaceHolders'
        QtMocHelpers::SlotData<void()>(261, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editRemoveCurrentPlaceHolder'
        QtMocHelpers::SlotData<void()>(262, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'normalCompletion'
        QtMocHelpers::SlotData<void()>(263, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertEnvironmentCompletion'
        QtMocHelpers::SlotData<void()>(264, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertTextCompletion'
        QtMocHelpers::SlotData<void()>(265, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertText'
        QtMocHelpers::SlotData<void(const QString &)>(266, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 143 },
        }}),
        // Slot 'insertTag'
        QtMocHelpers::SlotData<void(const QString &, int, int)>(267, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 268 }, { QMetaType::Int, 269 }, { QMetaType::Int, 270 },
        }}),
        // Slot 'insertTag'
        QtMocHelpers::SlotData<void(const QString &, int)>(267, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 268 }, { QMetaType::Int, 269 },
        }}),
        // Slot 'insertTag'
        QtMocHelpers::SlotData<void(const QString &)>(267, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 268 },
        }}),
        // Slot 'insertCitation'
        QtMocHelpers::SlotData<void(const QString &)>(271, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 143 },
        }}),
        // Slot 'insertFormula'
        QtMocHelpers::SlotData<void(const QString &)>(272, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 273 },
        }}),
        // Slot 'insertSymbol'
        QtMocHelpers::SlotData<void(const QString &)>(274, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 143 },
        }}),
        // Slot 'insertXmlTag'
        QtMocHelpers::SlotData<void(QListWidgetItem *)>(275, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 276, 47 },
        }}),
        // Slot 'insertXmlTagFromToolButtonAction'
        QtMocHelpers::SlotData<void()>(277, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'callToolButtonAction'
        QtMocHelpers::SlotData<void()>(278, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertFromAction'
        QtMocHelpers::SlotData<void()>(279, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertTextFromAction'
        QtMocHelpers::SlotData<void()>(280, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertFromTagList'
        QtMocHelpers::SlotData<void(QListWidgetItem *)>(281, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 276, 47 },
        }}),
        // Slot 'insertBib'
        QtMocHelpers::SlotData<void()>(282, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'openFromExplorer'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(283, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 284, 285 },
        }}),
        // Slot 'insertFromExplorer'
        QtMocHelpers::SlotData<void(bool)>(286, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 287 },
        }}),
        // Slot 'closeEnvironment'
        QtMocHelpers::SlotData<void()>(288, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertBibEntryFromAction'
        QtMocHelpers::SlotData<void()>(289, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertBibEntry'
        QtMocHelpers::SlotData<void(const QString &)>(290, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 291 },
        }}),
        // Slot 'insertBibEntry'
        QtMocHelpers::SlotData<void()>(290, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setBibTypeFromAction'
        QtMocHelpers::SlotData<void()>(292, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertUserTag'
        QtMocHelpers::SlotData<void()>(293, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'execMacro'
        QtMocHelpers::SlotData<void(const Macro &, const MacroExecContext &, bool)>(294, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 295, 296 }, { 0x80000000 | 297, 298 }, { QMetaType::Bool, 299 },
        }}),
        // Slot 'execMacro'
        QtMocHelpers::SlotData<void(const Macro &, const MacroExecContext &)>(294, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 295, 296 }, { 0x80000000 | 297, 298 },
        }}),
        // Slot 'execMacro'
        QtMocHelpers::SlotData<void(const Macro &)>(294, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 295, 296 },
        }}),
        // Slot 'runScript'
        QtMocHelpers::SlotData<void(const QString &, const MacroExecContext &, bool)>(300, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 301 }, { 0x80000000 | 297, 298 }, { QMetaType::Bool, 299 },
        }}),
        // Slot 'runScript'
        QtMocHelpers::SlotData<void(const QString &, const MacroExecContext &)>(300, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 301 }, { 0x80000000 | 297, 298 },
        }}),
        // Slot 'runScript'
        QtMocHelpers::SlotData<void(const QString &)>(300, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 301 },
        }}),
        // Slot 'editMacros'
        QtMocHelpers::SlotData<void()>(302, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'macroDialogAccepted'
        QtMocHelpers::SlotData<void()>(303, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'macroDialogRejected'
        QtMocHelpers::SlotData<void()>(304, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertRef'
        QtMocHelpers::SlotData<void(const QString &)>(305, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 214 },
        }}),
        // Slot 'insertRef'
        QtMocHelpers::SlotData<void()>(305, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertEqRef'
        QtMocHelpers::SlotData<void()>(306, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertPageRef'
        QtMocHelpers::SlotData<void()>(307, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'changeTextCodec'
        QtMocHelpers::SlotData<void()>(308, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateAvailableLanguages'
        QtMocHelpers::SlotData<void()>(309, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateLanguageToolStatus'
        QtMocHelpers::SlotData<void()>(310, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'editorSpellerChanged'
        QtMocHelpers::SlotData<void(const QString &)>(311, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 170 },
        }}),
        // Slot 'changeEditorSpeller'
        QtMocHelpers::SlotData<void()>(312, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'showMoreDictionaries'
        QtMocHelpers::SlotData<void()>(313, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertSpellcheckMagicComment'
        QtMocHelpers::SlotData<void()>(314, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateStatusBarEncoding'
        QtMocHelpers::SlotData<void()>(315, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addMagicRoot'
        QtMocHelpers::SlotData<void()>(316, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addMagicCoding'
        QtMocHelpers::SlotData<void()>(317, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addMagicBibliography'
        QtMocHelpers::SlotData<void()>(318, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addMagicProgram'
        QtMocHelpers::SlotData<void()>(319, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'quickTabular'
        QtMocHelpers::SlotData<void(const QMimeData *)>(320, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 321, 322 },
        }}),
        // Slot 'quickTabular'
        QtMocHelpers::SlotData<void()>(320, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'quickArray'
        QtMocHelpers::SlotData<void()>(323, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'quickTabbing'
        QtMocHelpers::SlotData<void()>(324, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'quickLetter'
        QtMocHelpers::SlotData<void()>(325, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'quickDocument'
        QtMocHelpers::SlotData<void()>(326, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'quickBeamer'
        QtMocHelpers::SlotData<void()>(327, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'quickGraphics'
        QtMocHelpers::SlotData<void(const QString &)>(328, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 329 },
        }}),
        // Slot 'quickGraphics'
        QtMocHelpers::SlotData<void()>(328, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'quickMath'
        QtMocHelpers::SlotData<void()>(330, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'aiChat'
        QtMocHelpers::SlotData<void(const QString)>(331, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 332 },
        }}),
        // Slot 'aiChat'
        QtMocHelpers::SlotData<void()>(331, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'checkProgramPermission'
        QtMocHelpers::SlotData<bool(const QString &, const QString &, LatexDocument *)>(333, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::QString, 334 }, { QMetaType::QString, 335 }, { 0x80000000 | 172, 336 },
        }}),
        // Slot 'runInternalPdfViewer'
        QtMocHelpers::SlotData<void(const QFileInfo &, const QString &)>(337, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 338, 336 }, { QMetaType::QString, 339 },
        }}),
        // Slot 'runBibliographyIfNecessary'
        QtMocHelpers::SlotData<void(const QFileInfo &)>(340, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 338, 341 },
        }}),
        // Slot 'GetBblLastModified'
        QtMocHelpers::SlotData<QDateTime()>(342, 2, QMC::AccessProtected, QMetaType::QDateTime),
        // Slot 'showExtendedSearch'
        QtMocHelpers::SlotData<void()>(343, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'changeIconSize'
        QtMocHelpers::SlotData<void(int)>(344, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 345 },
        }}),
        // Slot 'changeSecondaryIconSize'
        QtMocHelpers::SlotData<void(int)>(346, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 345 },
        }}),
        // Slot 'changePDFIconSize'
        QtMocHelpers::SlotData<void(int)>(347, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 345 },
        }}),
        // Slot 'changeSymbolGridIconSize'
        QtMocHelpers::SlotData<void(int, bool)>(348, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 345 }, { QMetaType::Bool, 349 },
        }}),
        // Slot 'changeSymbolGridIconSize'
        QtMocHelpers::SlotData<void(int)>(348, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 345 },
        }}),
        // Slot 'connectSubCommand'
        QtMocHelpers::SlotData<void(ProcessX *, bool)>(350, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 351, 352 }, { QMetaType::Bool, 353 },
        }}),
        // Slot 'runInternalCommand'
        QtMocHelpers::SlotData<void(const QString &, const QFileInfo &, const QString &)>(354, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 341 }, { 0x80000000 | 338, 336 }, { QMetaType::QString, 339 },
        }}),
        // Slot 'commandLineRequested'
        QtMocHelpers::SlotData<void(const QString &, QString *, bool *)>(355, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 335 }, { 0x80000000 | 356, 357 }, { 0x80000000 | 358, 2 },
        }}),
        // Slot 'beginRunningCommand'
        QtMocHelpers::SlotData<void(const QString &, bool, bool, bool)>(359, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 360 }, { QMetaType::Bool, 361 }, { QMetaType::Bool, 362 }, { QMetaType::Bool, 363 },
        }}),
        // Slot 'beginRunningSubCommand'
        QtMocHelpers::SlotData<void(ProcessX *, const QString &, const QString &, const RunCommandFlags &)>(364, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 351, 352 }, { QMetaType::QString, 360 }, { QMetaType::QString, 365 }, { 0x80000000 | 366, 367 },
        }}),
        // Slot 'endRunningSubCommand'
        QtMocHelpers::SlotData<void(ProcessX *, const QString &, const QString &, const RunCommandFlags &)>(368, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 351, 352 }, { QMetaType::QString, 360 }, { QMetaType::QString, 365 }, { 0x80000000 | 366, 367 },
        }}),
        // Slot 'endRunningCommand'
        QtMocHelpers::SlotData<void(const QString &, bool, bool, bool)>(369, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 360 }, { QMetaType::Bool, 361 }, { QMetaType::Bool, 362 }, { QMetaType::Bool, 363 },
        }}),
        // Slot 'runCommand'
        QtMocHelpers::SlotData<bool(const QString &, QString *, QTextCodec *, bool)>(370, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { QMetaType::QString, 371 }, { 0x80000000 | 356, 372 }, { 0x80000000 | 373, 374 }, { QMetaType::Bool, 375 },
        }}),
        // Slot 'runCommand'
        QtMocHelpers::SlotData<bool(const QString &, QString *, QTextCodec *)>(370, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 371 }, { 0x80000000 | 356, 372 }, { 0x80000000 | 373, 374 },
        }}),
        // Slot 'runCommand'
        QtMocHelpers::SlotData<bool(const QString &, QString *)>(370, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 371 }, { 0x80000000 | 356, 372 },
        }}),
        // Slot 'runCommand'
        QtMocHelpers::SlotData<bool(const QString &)>(370, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 371 },
        }}),
        // Slot 'runCommandNoSpecialChars'
        QtMocHelpers::SlotData<bool(QString, QString *, QTextCodec *)>(376, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { QMetaType::QString, 371 }, { 0x80000000 | 356, 372 }, { 0x80000000 | 373, 374 },
        }}),
        // Slot 'runCommandNoSpecialChars'
        QtMocHelpers::SlotData<bool(QString, QString *)>(376, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 371 }, { 0x80000000 | 356, 372 },
        }}),
        // Slot 'runCommandNoSpecialChars'
        QtMocHelpers::SlotData<bool(QString)>(376, 2, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 371 },
        }}),
        // Slot 'setStatusMessageProcess'
        QtMocHelpers::SlotData<void(const QString &)>(377, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Slot 'runCommandAsync'
        QtMocHelpers::SlotData<bool(const QString &, const char *)>(378, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { QMetaType::QString, 371 }, { 0x80000000 | 379, 380 },
        }}),
        // Slot 'processNotification'
        QtMocHelpers::SlotData<void(const QString &)>(381, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Slot 'clearLogs'
        QtMocHelpers::SlotData<void()>(382, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'openExternalTerminal'
        QtMocHelpers::SlotData<void()>(383, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'cleanAll'
        QtMocHelpers::SlotData<void()>(384, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'commandFromAction'
        QtMocHelpers::SlotData<void()>(385, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'webPublish'
        QtMocHelpers::SlotData<void()>(386, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'webPublishSource'
        QtMocHelpers::SlotData<void()>(387, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'convertToPlainText'
        QtMocHelpers::SlotData<void()>(388, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'analyseText'
        QtMocHelpers::SlotData<void()>(389, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'analyseTextFormDestroyed'
        QtMocHelpers::SlotData<void()>(390, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'generateRandomText'
        QtMocHelpers::SlotData<void()>(391, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'startCollabServer'
        QtMocHelpers::SlotData<void()>(392, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'connectCollabServer'
        QtMocHelpers::SlotData<void()>(393, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'disconnectCollabServer'
        QtMocHelpers::SlotData<void()>(394, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateCollabCursors'
        QtMocHelpers::SlotData<void(QDocumentCursor, QString)>(395, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 396 }, { QMetaType::QString, 397 },
        }}),
        // Slot 'removeCollabCursor'
        QtMocHelpers::SlotData<void(LatexDocument *, QString)>(398, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 }, { QMetaType::QString, 397 },
        }}),
        // Slot 'removeAllCollabCursor'
        QtMocHelpers::SlotData<void(QString)>(399, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 397 },
        }}),
        // Slot 'updateCollabChanges'
        QtMocHelpers::SlotData<void(QDocumentCursor, QString, QString)>(400, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 396 }, { QMetaType::QString, 401 }, { QMetaType::QString, 402 },
        }}),
        // Slot 'updateCollaborationEditors'
        QtMocHelpers::SlotData<void(int, int, int, int, const QString &)>(403, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 404 }, { QMetaType::Int, 405 }, { QMetaType::Int, 406 }, { QMetaType::Int, 407 },
            { QMetaType::QString, 401 },
        }}),
        // Slot 'registerFileForCollab'
        QtMocHelpers::SlotData<bool(const QString)>(408, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'collabClientFinished'
        QtMocHelpers::SlotData<void(int, QString)>(409, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 410 }, { QMetaType::QString, 411 },
        }}),
        // Slot 'guestServerSuccessfullyStarted'
        QtMocHelpers::SlotData<void()>(412, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'hostServerSuccessfullyStarted'
        QtMocHelpers::SlotData<void()>(413, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateCollabStatus'
        QtMocHelpers::SlotData<void()>(414, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'copyCollabLinkToClipboard'
        QtMocHelpers::SlotData<void()>(415, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'loadLog'
        QtMocHelpers::SlotData<bool()>(416, 2, QMC::AccessProtected, QMetaType::Bool),
        // Slot 'onCompileError'
        QtMocHelpers::SlotData<void()>(417, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setLogMarksVisible'
        QtMocHelpers::SlotData<void(bool)>(418, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 287 },
        }}),
        // Slot 'clearLogEntriesInEditors'
        QtMocHelpers::SlotData<void()>(419, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateLogEntriesInEditors'
        QtMocHelpers::SlotData<void()>(420, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'showLog'
        QtMocHelpers::SlotData<void()>(421, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewLog'
        QtMocHelpers::SlotData<void()>(422, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewLogOrReRun'
        QtMocHelpers::SlotData<void(LatexCompileResult *)>(423, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 424, 357 },
        }}),
        // Slot 'gotoNearLogEntry'
        QtMocHelpers::SlotData<bool(int, bool, QString)>(425, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::Int, 426 }, { QMetaType::Bool, 215 }, { QMetaType::QString, 427 },
        }}),
        // Slot 'hasLatexErrors'
        QtMocHelpers::SlotData<bool()>(428, 2, QMC::AccessProtected, QMetaType::Bool),
        // Slot 'logExists'
        QtMocHelpers::SlotData<bool()>(429, 2, QMC::AccessProtected, QMetaType::Bool),
        // Slot 'clearMarkers'
        QtMocHelpers::SlotData<void()>(430, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'latexHelp'
        QtMocHelpers::SlotData<void()>(431, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'userManualHelp'
        QtMocHelpers::SlotData<void()>(432, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'texdocHelp'
        QtMocHelpers::SlotData<void()>(433, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'helpAbout'
        QtMocHelpers::SlotData<void()>(434, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'generalOptions'
        QtMocHelpers::SlotData<void()>(435, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setAutomaticRootDetection'
        QtMocHelpers::SlotData<void()>(436, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setExplicitRootDocument'
        QtMocHelpers::SlotData<void(LatexDocument *)>(437, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 },
        }}),
        // Slot 'setCurrentDocAsExplicitRoot'
        QtMocHelpers::SlotData<void()>(438, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'gotoNextDocument'
        QtMocHelpers::SlotData<void()>(439, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'gotoPrevDocument'
        QtMocHelpers::SlotData<void()>(440, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'gotoOpenDocument'
        QtMocHelpers::SlotData<void()>(441, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateOpenDocumentMenu'
        QtMocHelpers::SlotData<void(bool)>(442, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 443 },
        }}),
        // Slot 'updateOpenDocumentMenu'
        QtMocHelpers::SlotData<void()>(442, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'onEditorsReordered'
        QtMocHelpers::SlotData<void()>(444, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'focusEditor'
        QtMocHelpers::SlotData<void()>(445, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'focusViewer'
        QtMocHelpers::SlotData<void()>(446, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'enlargeEmbeddedPDFViewer'
        QtMocHelpers::SlotData<void()>(447, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'shrinkEmbeddedPDFViewer'
        QtMocHelpers::SlotData<void(bool)>(448, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 449 },
        }}),
        // Slot 'shrinkEmbeddedPDFViewer'
        QtMocHelpers::SlotData<void()>(448, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setEnabledMenusEnlargeShrink'
        QtMocHelpers::SlotData<void(bool, bool)>(450, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 451 }, { QMetaType::Bool, 452 },
        }}),
        // Slot 'showStatusbar'
        QtMocHelpers::SlotData<void()>(453, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewCloseElement'
        QtMocHelpers::SlotData<void()>(454, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setFullScreenMode'
        QtMocHelpers::SlotData<void()>(455, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewSetHighlighting'
        QtMocHelpers::SlotData<void(QAction *)>(456, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 457, 458 },
        }}),
        // Slot 'showHighlightingMenu'
        QtMocHelpers::SlotData<void()>(459, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewCollapseBlock'
        QtMocHelpers::SlotData<void()>(460, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'viewExpandBlock'
        QtMocHelpers::SlotData<void()>(461, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'newPdfPreviewer'
        QtMocHelpers::SlotData<QObject *(bool)>(462, 2, QMC::AccessProtected, QMetaType::QObjectStar, {{
            { QMetaType::Bool, 463 },
        }}),
        // Slot 'newPdfPreviewer'
        QtMocHelpers::SlotData<QObject *()>(462, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::QObjectStar),
        // Slot 'pdfClosed'
        QtMocHelpers::SlotData<void()>(464, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'masterDocumentChanged'
        QtMocHelpers::SlotData<void(LatexDocument *)>(465, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 },
        }}),
        // Slot 'aboutToDeleteDocument'
        QtMocHelpers::SlotData<void(LatexDocument *)>(466, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 },
        }}),
        // Slot 'updateCompleter'
        QtMocHelpers::SlotData<void(LatexEditorView *)>(467, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 13, 468 },
        }}),
        // Slot 'updateCompleter'
        QtMocHelpers::SlotData<void()>(467, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'completerNeedsUpdate'
        QtMocHelpers::SlotData<void()>(469, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'completerCommandsNeedsUpdate'
        QtMocHelpers::SlotData<void()>(470, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'needUpdatedCompleter'
        QtMocHelpers::SlotData<void()>(471, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'outputPageChanged'
        QtMocHelpers::SlotData<void(const QString &)>(472, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 291 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(int, int, LatexEditorView *, QEditor::MoveFlags, bool)>(473, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 207 }, { QMetaType::Int, 208 }, { 0x80000000 | 13, 468 }, { 0x80000000 | 474, 475 },
            { QMetaType::Bool, 476 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(int, int, LatexEditorView *, QEditor::MoveFlags)>(473, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 207 }, { QMetaType::Int, 208 }, { 0x80000000 | 13, 468 }, { 0x80000000 | 474, 475 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(int, int, LatexEditorView *)>(473, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 207 }, { QMetaType::Int, 208 }, { 0x80000000 | 13, 468 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(int, int)>(473, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 207 }, { QMetaType::Int, 208 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(int)>(473, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 207 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<bool(int, const QString &)>(473, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::Int, 207 }, { QMetaType::QString, 84 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(LatexDocument *, int, int)>(473, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 }, { QMetaType::Int, 207 }, { QMetaType::Int, 208 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(LatexDocument *, int)>(473, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 172, 120 }, { QMetaType::Int, 207 },
        }}),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void(QTreeWidgetItem *, int)>(473, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 43, 47 }, { QMetaType::Int, 208 },
        }}),
        // Slot 'gotoLogEntryEditorOnly'
        QtMocHelpers::SlotData<void(int)>(477, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 478 },
        }}),
        // Slot 'getLogEntryContextCursor'
        QtMocHelpers::SlotData<QDocumentCursor(const QDocumentLineHandle *, const LatexLogEntry &)>(479, 2, QMC::AccessProtected, 0x80000000 | 204, {{
            { 0x80000000 | 480, 481 }, { 0x80000000 | 482, 68 },
        }}),
        // Slot 'gotoLogEntryAt'
        QtMocHelpers::SlotData<bool(int)>(483, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::Int, 484 },
        }}),
        // Slot 'gotoMark'
        QtMocHelpers::SlotData<bool(bool, int)>(485, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::Bool, 215 }, { QMetaType::Int, 291 },
        }}),
        // Slot 'gotoMark'
        QtMocHelpers::SlotData<bool(bool)>(485, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::Bool, 215 },
        }}),
        // Slot 'findOccurencesApproximate'
        QtMocHelpers::SlotData<QList<int>(QString, const QString &)>(486, 2, QMC::AccessProtected, 0x80000000 | 243, {{
            { QMetaType::QString, 487 }, { QMetaType::QString, 488 },
        }}),
        // Slot 'syncFromViewer'
        QtMocHelpers::SlotData<void(const QString &, int, bool, const QString &)>(489, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 84 }, { QMetaType::Int, 122 }, { QMetaType::Bool, 490 }, { QMetaType::QString, 488 },
        }}),
        // Slot 'goBack'
        QtMocHelpers::SlotData<void()>(491, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'goForward'
        QtMocHelpers::SlotData<void()>(492, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setGlobalCursor'
        QtMocHelpers::SlotData<void(const QDocumentCursor &)>(493, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 26 },
        }}),
        // Slot 'saveCurrentCursorToHistory'
        QtMocHelpers::SlotData<void()>(494, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'saveEditorCursorToHistory'
        QtMocHelpers::SlotData<void(LatexEditorView *)>(495, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 13, 468 },
        }}),
        // Slot 'previewLatex'
        QtMocHelpers::SlotData<void()>(496, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'previewAvailable'
        QtMocHelpers::SlotData<void(const QString &, const PreviewSource &)>(497, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 498 }, { 0x80000000 | 499, 500 },
        }}),
        // Slot 'clearPreview'
        QtMocHelpers::SlotData<void()>(501, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'showPreview'
        QtMocHelpers::SlotData<void(const QString &)>(502, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 143 },
        }}),
        // Slot 'showPreview'
        QtMocHelpers::SlotData<void(const QDocumentCursor &)>(502, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 26 },
        }}),
        // Slot 'showPreview'
        QtMocHelpers::SlotData<void(const QDocumentCursor &, bool)>(502, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 26 }, { QMetaType::Bool, 503 },
        }}),
        // Slot 'makePreviewHeader'
        QtMocHelpers::SlotData<QStringList(const LatexDocument *)>(504, 2, QMC::AccessProtected, QMetaType::QStringList, {{
            { 0x80000000 | 505, 506 },
        }}),
        // Slot 'showPreviewQueue'
        QtMocHelpers::SlotData<void()>(507, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'showImgPreview'
        QtMocHelpers::SlotData<void(const QString &)>(508, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 509 },
        }}),
        // Slot 'showImgPreviewFinished'
        QtMocHelpers::SlotData<void(const QPixmap &, int)>(510, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 511, 512 }, { QMetaType::Int, 513 },
        }}),
        // Slot 'recompileForPreview'
        QtMocHelpers::SlotData<void()>(514, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'recompileForPreviewNow'
        QtMocHelpers::SlotData<void()>(515, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'templateEdit'
        QtMocHelpers::SlotData<void(const QString &)>(516, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 509 },
        }}),
        // Slot 'fileReloaded'
        QtMocHelpers::SlotData<void()>(517, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileInConflictShowDiff'
        QtMocHelpers::SlotData<void()>(518, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'fileAutoReloading'
        QtMocHelpers::SlotData<void(QString)>(519, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 509 },
        }}),
        // Slot 'jumpToSearchResult'
        QtMocHelpers::SlotData<void(LatexDocument *, int, const SearchQuery *)>(520, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 172, 120 }, { QMetaType::Int, 521 }, { 0x80000000 | 522, 219 },
        }}),
        // Slot 'jumpToFileSearchResult'
        QtMocHelpers::SlotData<void(QString, int, const SearchQuery *)>(523, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { QMetaType::Int, 521 }, { 0x80000000 | 522, 219 },
        }}),
        // Slot 'cursorPositionChanged'
        QtMocHelpers::SlotData<void()>(524, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'syncPDFViewer'
        QtMocHelpers::SlotData<void(QDocumentCursor, bool)>(525, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 204, 396 }, { QMetaType::Bool, 526 },
        }}),
        // Slot 'syncPDFViewer'
        QtMocHelpers::SlotData<void(QDocumentCursor)>(525, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 204, 396 },
        }}),
        // Slot 'generateMirror'
        QtMocHelpers::SlotData<bool(bool)>(527, 2, QMC::AccessProtected, QMetaType::Bool, {{
            { QMetaType::Bool, 528 },
        }}),
        // Slot 'generateMirror'
        QtMocHelpers::SlotData<bool()>(527, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'generateBracketInverterMirror'
        QtMocHelpers::SlotData<void()>(529, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'jumpToBracket'
        QtMocHelpers::SlotData<void()>(530, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'selectBracket'
        QtMocHelpers::SlotData<void()>(531, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'findMissingBracket'
        QtMocHelpers::SlotData<void()>(532, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'cursorHovered'
        QtMocHelpers::SlotData<void()>(533, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'loadProfile'
        QtMocHelpers::SlotData<void()>(534, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'saveProfile'
        QtMocHelpers::SlotData<void()>(535, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addRowCB'
        QtMocHelpers::SlotData<void()>(536, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addColumnCB'
        QtMocHelpers::SlotData<void()>(537, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'removeColumnCB'
        QtMocHelpers::SlotData<void()>(538, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'removeRowCB'
        QtMocHelpers::SlotData<void()>(539, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'cutColumnCB'
        QtMocHelpers::SlotData<void()>(540, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'pasteColumnCB'
        QtMocHelpers::SlotData<void()>(541, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'addHLineCB'
        QtMocHelpers::SlotData<void()>(542, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'remHLineCB'
        QtMocHelpers::SlotData<void()>(543, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'insertTableTemplate'
        QtMocHelpers::SlotData<void()>(544, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'alignTableCols'
        QtMocHelpers::SlotData<void()>(545, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateTexQNFA'
        QtMocHelpers::SlotData<void()>(546, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateTexLikeQNFA'
        QtMocHelpers::SlotData<void(QString, QString)>(547, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 548 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'toggleGrammar'
        QtMocHelpers::SlotData<void(int)>(549, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 223 },
        }}),
        // Slot 'openInternalDocViewer'
        QtMocHelpers::SlotData<void(QString, const QString)>(550, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 551 }, { QMetaType::QString, 552 },
        }}),
        // Slot 'openInternalDocViewer'
        QtMocHelpers::SlotData<void(QString)>(550, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 551 },
        }}),
        // Slot 'importPackage'
        QtMocHelpers::SlotData<void(QString)>(553, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 170 },
        }}),
        // Slot 'packageScanCompleted'
        QtMocHelpers::SlotData<void(QString)>(554, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 170 },
        }}),
        // Slot 'stopPackageParser'
        QtMocHelpers::SlotData<void()>(555, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'packageParserFinished'
        QtMocHelpers::SlotData<void()>(556, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readinAllPackageNames'
        QtMocHelpers::SlotData<void()>(557, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'packageListReadCompleted'
        QtMocHelpers::SlotData<void(std::set<QString>)>(558, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 559, 560 },
        }}),
        // Slot 'threadCrashed'
        QtMocHelpers::SlotData<void()>(561, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'iamalive'
        QtMocHelpers::SlotData<void()>(562, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkLatexInstall'
        QtMocHelpers::SlotData<void()>(563, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkCWLs'
        QtMocHelpers::SlotData<void()>(564, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkLanguageTool'
        QtMocHelpers::SlotData<void()>(565, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slowOperationStarted'
        QtMocHelpers::SlotData<void()>(566, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slowOperationEnded'
        QtMocHelpers::SlotData<void()>(567, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openBugsAndFeatures'
        QtMocHelpers::SlotData<void()>(568, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'maniplateDockingTabBars'
        QtMocHelpers::SlotData<void()>(569, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addDock'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &, QWidget *)>(570, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 170 }, { QMetaType::QString, 571 }, { QMetaType::QString, 572 }, { 0x80000000 | 32, 573 },
        }}),
        // Slot 'toggleDocks'
        QtMocHelpers::SlotData<void(bool)>(574, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 287 },
        }}),
        // Slot 'resetDocks'
        QtMocHelpers::SlotData<void()>(575, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleDockVisibility'
        QtMocHelpers::SlotData<void()>(576, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateDockVisibility'
        QtMocHelpers::SlotData<void(bool)>(577, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 287 },
        }}),
        // Slot 'checkDockSpread'
        QtMocHelpers::SlotData<bool()>(578, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'getCurrentFileName'
        QtMocHelpers::MethodData<QString()>(579, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &, const QString &)>(580, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 581 }, { QMetaType::QString, 582 },
        }}),
        // Method 'getAbsoluteFilePath'
        QtMocHelpers::MethodData<QString(const QString &)>(580, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 581 },
        }}),
        // Method 'getRelativeFileName'
        QtMocHelpers::MethodData<QString(const QString &, QString, bool)>(583, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 584 }, { QMetaType::QString, 585 }, { QMetaType::Bool, 586 },
        }}),
        // Method 'getRelativeFileName'
        QtMocHelpers::MethodData<QString(const QString &, QString)>(583, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 584 }, { QMetaType::QString, 585 },
        }}),
        // Method 'fileExists'
        QtMocHelpers::MethodData<bool(const QString &)>(587, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 584 },
        }}),
        // Method 'runInternalCommand'
        QtMocHelpers::MethodData<void(const QString &, const QString &, const QString &)>(354, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 341 }, { QMetaType::QString, 336 }, { QMetaType::QString, 339 },
        }}),
        // Method 'newManagedMenu'
        QtMocHelpers::MethodData<QMenu *(const QString &, const QString &)>(588, 2, QMC::AccessProtected, 0x80000000 | 589, {{
            { QMetaType::QString, 291 }, { QMetaType::QString, 143 },
        }}),
        // Method 'newManagedMenu'
        QtMocHelpers::MethodData<QMenu *(QMenu *, const QString &, const QString &)>(588, 2, QMC::AccessProtected, 0x80000000 | 589, {{
            { 0x80000000 | 589, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QKeySequence &, const QString &, const QList<QVariant> &)>(591, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 }, { QMetaType::QString, 595 }, { 0x80000000 | 596, 19 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QKeySequence &, const QString &)>(591, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 }, { QMetaType::QString, 595 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QKeySequence &)>(591, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *)>(591, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &)>(591, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QList<QKeySequence> &, const QString &, const QList<QVariant> &)>(591, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 597, 598 }, { QMetaType::QString, 595 }, { 0x80000000 | 596, 19 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QList<QKeySequence> &, const QString &)>(591, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 597, 598 }, { QMetaType::QString, 595 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QList<QKeySequence> &)>(591, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 597, 598 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QKeySequence &, const QString &, const QList<QVariant> &)>(599, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 }, { QMetaType::QString, 595 }, { 0x80000000 | 596, 19 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QKeySequence &, const QString &)>(599, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 }, { QMetaType::QString, 595 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QKeySequence &)>(599, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *)>(599, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &)>(599, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QList<QKeySequence> &, const QString &, const QList<QVariant> &)>(599, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 597, 598 }, { QMetaType::QString, 595 }, { 0x80000000 | 596, 19 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QList<QKeySequence> &, const QString &)>(599, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 597, 598 }, { QMetaType::QString, 595 },
        }}),
        // Method 'newManagedEditorAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, const QString &, const char *, const QList<QKeySequence> &)>(599, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 597, 598 },
        }}),
        // Method 'newManagedAction'
        QtMocHelpers::MethodData<QAction *(QWidget *, const QString &, QAction *)>(591, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { 0x80000000 | 32, 590 }, { QMetaType::QString, 291 }, { 0x80000000 | 457, 458 },
        }}),
        // Method 'getManagedMenu'
        QtMocHelpers::MethodData<QMenu *(const QString &)>(600, 2, QMC::AccessProtected, 0x80000000 | 589, {{
            { QMetaType::QString, 291 },
        }}),
        // Method 'getManagedAction'
        QtMocHelpers::MethodData<QAction *(const QString &)>(601, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { QMetaType::QString, 291 },
        }}),
        // Method 'getManagedActions'
        QtMocHelpers::MethodData<QList<QAction*>(const QStringList &, const QString &)>(602, 2, QMC::AccessProtected, 0x80000000 | 603, {{
            { QMetaType::QStringList, 604 }, { QMetaType::QString, 605 },
        }}),
        // Method 'getManagedActions'
        QtMocHelpers::MethodData<QList<QAction*>(const QStringList &)>(602, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 603, {{
            { QMetaType::QStringList, 604 },
        }}),
        // Method 'insertManagedAction'
        QtMocHelpers::MethodData<QAction *(QAction *, const QString &, const QString &, const char *, const QKeySequence &, const QString &)>(606, 2, QMC::AccessProtected, 0x80000000 | 457, {{
            { 0x80000000 | 457, 607 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 }, { QMetaType::QString, 595 },
        }}),
        // Method 'insertManagedAction'
        QtMocHelpers::MethodData<QAction *(QAction *, const QString &, const QString &, const char *, const QKeySequence &)>(606, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 457, 607 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
            { 0x80000000 | 593, 594 },
        }}),
        // Method 'insertManagedAction'
        QtMocHelpers::MethodData<QAction *(QAction *, const QString &, const QString &, const char *)>(606, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 457, 607 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 }, { 0x80000000 | 379, 592 },
        }}),
        // Method 'insertManagedAction'
        QtMocHelpers::MethodData<QAction *(QAction *, const QString &, const QString &)>(606, 2, QMC::AccessProtected | QMC::MethodCloned, 0x80000000 | 457, {{
            { 0x80000000 | 457, 607 }, { QMetaType::QString, 291 }, { QMetaType::QString, 143 },
        }}),
        // Method 'loadManagedMenu'
        QtMocHelpers::MethodData<void(const QString &)>(608, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Method 'setupToolBars'
        QtMocHelpers::MethodData<void()>(609, 2, QMC::AccessProtected, QMetaType::Void),
        // Method 'completerIsVisible'
        QtMocHelpers::MethodData<bool()>(610, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'currentEditorView'
        QtMocHelpers::MethodData<LatexEditorView *() const>(611, 2, QMC::AccessPrivate, 0x80000000 | 13),
        // Method 'currentEditor'
        QtMocHelpers::MethodData<QEditor *() const>(612, 2, QMC::AccessPrivate, 0x80000000 | 94),
        // Method 'clipboardText'
        QtMocHelpers::MethodData<QString(const QClipboard::Mode &) const>(613, 2, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 614, 615 },
        }}),
        // Method 'clipboardText'
        QtMocHelpers::MethodData<QString() const>(613, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Method 'setClipboardText'
        QtMocHelpers::MethodData<void(const QString &, const QClipboard::Mode &)>(616, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 143 }, { 0x80000000 | 614, 615 },
        }}),
        // Method 'setClipboardText'
        QtMocHelpers::MethodData<void(const QString &)>(616, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 143 },
        }}),
        // Method 'getVersion'
        QtMocHelpers::MethodData<int() const>(617, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'simulateKeyPress'
        QtMocHelpers::MethodData<void(const QString &)>(618, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 619 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'clipboard'
        QtMocHelpers::PropertyData<QString>(620, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Texstudio, qt_meta_tag_ZN9TexstudioE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Texstudio::staticMetaObject = { {
    QMetaObject::SuperData::link<QMainWindow::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9TexstudioE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9TexstudioE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9TexstudioE_t>.metaTypes,
    nullptr
} };

void Texstudio::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Texstudio *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->infoNewFile(); break;
        case 1: _t->infoNewFromTemplate(); break;
        case 2: _t->infoLoadFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->infoFileSaved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 4: _t->infoFileSaved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->infoFileClosed(); break;
        case 6: _t->infoAfterTypeset(); break;
        case 7: _t->imgPreview((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: { LatexEditorView* _r = _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 9: { LatexEditorView* _r = _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 10: { LatexEditorView* _r = _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 11: { LatexEditorView* _r = _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 12: _t->executeCommandLine((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 13: _t->startupCompleted(); break;
        case 14: _t->onOtherInstanceMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 15: _t->fuzzCursorHistory(); break;
        case 16: _t->fuzzBackForward(); break;
        case 17: _t->setBuildButtonsDisabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->updateToolBarMenu((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->showTestProgress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->leftPanelChanged((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1]))); break;
        case 21: _t->updateTOCs(); break;
        case 22: _t->updateAllTOCs(); break;
        case 23: _t->updateTOC(); break;
        case 24: _t->updateCurrentPosInTOC((*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[2]))); break;
        case 25: _t->updateCurrentPosInTOC((*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[1]))); break;
        case 26: _t->updateCurrentPosInTOC(); break;
        case 27: _t->updateCurrentPosInStructure((*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[2]))); break;
        case 28: _t->updateCurrentPosInStructure((*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[1]))); break;
        case 29: _t->updateCurrentPosInStructure(); break;
        case 30: _t->updateCurrentPosInTOCHelper((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 31: _t->updateCurrentPosInTOCHelper((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[3]))); break;
        case 32: _t->updateCurrentPosInTOCHelper((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<StructureEntry*>>(_a[2]))); break;
        case 33: _t->updateCurrentPosInTOCHelper((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1]))); break;
        case 34: _t->updateCurrentPosInTOCHelper(); break;
        case 35: _t->syncExpanded((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1]))); break;
        case 36: _t->syncCollapsed((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1]))); break;
        case 37: _t->editSectionCopy(); break;
        case 38: _t->editSectionCut(); break;
        case 39: _t->editSectionPasteAfter(); break;
        case 40: _t->editSectionPasteBefore(); break;
        case 41: _t->editIndentSection(); break;
        case 42: _t->editUnIndentSection(); break;
        case 43: _t->gotoLineFromAction(); break;
        case 44: _t->openAllRelatedDocuments(); break;
        case 45: _t->closeAllRelatedDocuments(); break;
        case 46: _t->toggleMasterDocument(); break;
        case 47: _t->closeDocument(); break;
        case 48: _t->copyFileName(); break;
        case 49: _t->copyFilePath(); break;
        case 50: _t->showInGraphicalShell_(); break;
        case 51: _t->toggleSingleDocMode(); break;
        case 52: _t->expandSubitems(); break;
        case 53: _t->collapseSubitems(); break;
        case 54: { StructureEntry* _r = _t->labelForStructureEntry((*reinterpret_cast<std::add_pointer_t<const StructureEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<StructureEntry**>(_a[0]) = std::move(_r); }  break;
        case 55: _t->updateStructureLocally((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 56: _t->updateStructureLocally(); break;
        case 57: _t->customMenuStructure((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 58: _t->createLabelFromAction(); break;
        case 59: _t->relayToEditorSlot(); break;
        case 60: _t->relayToOwnSlot(); break;
        case 61: _t->autoRunScripts(); break;
        case 62: _t->runScripts((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 63: _t->runScriptsInList((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<Macro>>>(_a[2]))); break;
        case 64: _t->fileNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->fileNew(); break;
        case 66: _t->fileNewFromTemplate(); break;
        case 67: _t->fileMakeTemplate(); break;
        case 68: _t->fileOpen((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 69: _t->fileOpen(); break;
        case 70: _t->fileRestoreSession((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 71: _t->fileRestoreSession((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 72: _t->fileRestoreSession(); break;
        case 73: _t->fileSave((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QEditor*>>(_a[2]))); break;
        case 74: _t->fileSave((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 75: _t->fileSave(); break;
        case 76: _t->fileSaveAll(); break;
        case 77: _t->fileSaveAllFromTimer(); break;
        case 78: _t->fileSaveAll((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 79: _t->fileSaveAs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 80: _t->fileSaveAs(); break;
        case 81: _t->fileSaveAs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 82: _t->fileNewInternal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 83: _t->fileNewInternal(); break;
        case 84: _t->fileUtilCopyMove((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 85: _t->fileUtilDelete(); break;
        case 86: _t->fileUtilRevert(); break;
        case 87: _t->fileUtilPermissions(); break;
        case 88: _t->fileUtilCopyFileName(); break;
        case 89: _t->fileUtilCopyMasterFileName(); break;
        case 90: _t->fileClose(); break;
        case 91: _t->fileCloseAll(); break;
        case 92: _t->fileExit(); break;
        case 93: _t->fileExitWithError(); break;
        case 94: _t->fileOpenRecent(); break;
        case 95: _t->fileOpenAllRecent(); break;
        case 96: _t->fileRecentList(); break;
        case 97: _t->fileClearRecentList(); break;
        case 98: _t->fileRemoveFromRecentList((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 99: _t->viewDocumentListHidden(); break;
        case 100: _t->fileDocumentOpenFromChoosen((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 101: _t->viewDocumentList(); break;
        case 102: _t->viewDocumentOpenFromChoosen((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 103: _t->fileOpenFirstNonOpen(); break;
        case 104: _t->fileOpenRecentProject(); break;
        case 105: _t->fileLoadSession(); break;
        case 106: _t->loadSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 107: _t->fileSaveSession(); break;
        case 108: _t->restoreSession((*reinterpret_cast<std::add_pointer_t<Session>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 109: _t->restoreSession((*reinterpret_cast<std::add_pointer_t<Session>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 110: _t->restoreSession((*reinterpret_cast<std::add_pointer_t<Session>>(_a[1]))); break;
        case 111: { Session _r = _t->getCurrentSession();
            if (_a[0]) *reinterpret_cast<Session*>(_a[0]) = std::move(_r); }  break;
        case 112: _t->MarkCurrentFileAsRecent(); break;
        case 113: _t->fileCheckin((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 114: _t->fileCheckin(); break;
        case 115: _t->fileLockPdf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 116: _t->fileLockPdf(); break;
        case 117: _t->fileCheckinPdf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 118: _t->fileCheckinPdf(); break;
        case 119: _t->fileUpdate((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 120: _t->fileUpdate(); break;
        case 121: _t->fileUpdateCWD((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 122: _t->fileUpdateCWD(); break;
        case 123: _t->checkinAfterSave((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 124: _t->checkinAfterSave((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 125: _t->checkin((*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 126: _t->checkin((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 127: _t->checkin((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 128: { bool _r = _t->svnadd((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 129: { bool _r = _t->svnadd((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 130: _t->svnUndo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 131: _t->svnUndo(); break;
        case 132: _t->svnPatch((*reinterpret_cast<std::add_pointer_t<QEditor*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 133: _t->showOldRevisions(); break;
        case 134: _t->changeToRevision((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 135: _t->changeToRevision((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 136: _t->svnDialogClosed((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 137: _t->fileDiff(); break;
        case 138: _t->fileDiff3(); break;
        case 139: { bool _r = _t->checkSVNConflicted((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 140: { bool _r = _t->checkSVNConflicted();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 141: _t->removeDiffMarkers((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 142: _t->removeDiffMarkers(); break;
        case 143: _t->editChangeDiff((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 144: _t->jumpNextDiff(); break;
        case 145: _t->jumpPrevDiff(); break;
        case 146: _t->fileDiffMerge(); break;
        case 147: _t->declareConflictResolved(); break;
        case 148: { LatexEditorView* _r = _t->openExternalFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 149: { LatexEditorView* _r = _t->openExternalFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 150: { LatexEditorView* _r = _t->openExternalFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 151: { LatexEditorView* _r = _t->openExternalFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 152: _t->openExternalFileFromAction(); break;
        case 153: _t->editUndo(); break;
        case 154: _t->editRedo(); break;
        case 155: _t->editDebugUndoStack(); break;
        case 156: _t->editCopy(); break;
        case 157: _t->editPaste(); break;
        case 158: _t->editPasteImage((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1]))); break;
        case 159: _t->editTextToLowercase(); break;
        case 160: _t->editTextToUppercase(); break;
        case 161: _t->editTextToTitlecase((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 162: _t->editTextToTitlecase(); break;
        case 163: _t->editTextToTitlecaseSmart(); break;
        case 164: _t->editFind(); break;
        case 165: _t->editPasteLatex(); break;
        case 166: _t->convertToLatex(); break;
        case 167: _t->editHardLineBreak(); break;
        case 168: _t->editHardLineBreakRepeat(); break;
        case 169: _t->editDeleteLine(); break;
        case 170: _t->editCutLine(); break;
        case 171: _t->editDeleteToEndOfLine(); break;
        case 172: _t->editDeleteFromStartOfLine(); break;
        case 173: _t->editMoveLineUp(); break;
        case 174: _t->editMoveLineDown(); break;
        case 175: _t->editDuplicateLine(); break;
        case 176: _t->editSortLines(); break;
        case 177: _t->editAlignMirrors(); break;
        case 178: _t->editEraseWordCmdEnv(); break;
        case 179: _t->editGotoDefinition((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 180: _t->editGotoDefinition(); break;
        case 181: _t->editSpell(); break;
        case 182: _t->editThesaurus((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 183: _t->editThesaurus((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 184: _t->editThesaurus(); break;
        case 185: _t->editChangeLineEnding(); break;
        case 186: _t->setPreviewMode(); break;
        case 187: _t->editSetupEncoding(); break;
        case 188: _t->editInsertUnicode(); break;
        case 189: _t->editInsertRefToNextLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 190: _t->editInsertRefToNextLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 191: _t->editInsertRefToNextLabel(); break;
        case 192: _t->editInsertRefToPrevLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 193: _t->editInsertRefToPrevLabel(); break;
        case 194: _t->runSearch((*reinterpret_cast<std::add_pointer_t<SearchQuery*>>(_a[1]))); break;
        case 195: _t->findLabelUsages((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 196: _t->findSpecialUsages((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 197: _t->findLabelUsagesFromAction(); break;
        case 198: { SearchResultWidget* _r = _t->searchResultWidget();
            if (_a[0]) *reinterpret_cast<SearchResultWidget**>(_a[0]) = std::move(_r); }  break;
        case 199: _t->findWordRepetions(); break;
        case 200: _t->findNextWordRepetion(); break;
        case 201: _t->LTErrorMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 202: _t->paletteChanged((*reinterpret_cast<std::add_pointer_t<QPalette>>(_a[1]))); break;
        case 203: _t->colorSchemeChanged((*reinterpret_cast<std::add_pointer_t<Qt::ColorScheme>>(_a[1]))); break;
        case 204: _t->readSettings((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 205: _t->readSettings(); break;
        case 206: _t->saveSettings((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 207: _t->saveSettings(); break;
        case 208: _t->restoreDefaultSettings(); break;
        case 209: _t->showSettings(); break;
        case 210: _t->showMarkTooltipForLogMessage((*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[1]))); break;
        case 211: _t->newDocumentLineEnding(); break;
        case 212: _t->updateCaption(); break;
        case 213: _t->updateMasterDocumentCaption(); break;
        case 214: _t->updateUndoRedoStatus(); break;
        case 215: _t->currentEditorChanged(); break;
        case 216: _t->editorTabMoved((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 217: _t->editorAboutToChangeByTabClick((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[2]))); break;
        case 218: _t->updateStructure((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 219: _t->updateStructure((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[2]))); break;
        case 220: _t->updateStructure((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 221: _t->updateStructure(); break;
        case 222: _t->structureContextMenuToggleMasterDocument((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 223: _t->editRemovePlaceHolders(); break;
        case 224: _t->editRemoveCurrentPlaceHolder(); break;
        case 225: _t->normalCompletion(); break;
        case 226: _t->insertEnvironmentCompletion(); break;
        case 227: _t->insertTextCompletion(); break;
        case 228: _t->insertText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 229: _t->insertTag((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 230: _t->insertTag((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 231: _t->insertTag((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 232: _t->insertCitation((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 233: _t->insertFormula((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 234: _t->insertSymbol((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 235: _t->insertXmlTag((*reinterpret_cast<std::add_pointer_t<QListWidgetItem*>>(_a[1]))); break;
        case 236: _t->insertXmlTagFromToolButtonAction(); break;
        case 237: _t->callToolButtonAction(); break;
        case 238: _t->insertFromAction(); break;
        case 239: _t->insertTextFromAction(); break;
        case 240: _t->insertFromTagList((*reinterpret_cast<std::add_pointer_t<QListWidgetItem*>>(_a[1]))); break;
        case 241: _t->insertBib(); break;
        case 242: _t->openFromExplorer((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 243: _t->insertFromExplorer((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 244: _t->closeEnvironment(); break;
        case 245: _t->insertBibEntryFromAction(); break;
        case 246: _t->insertBibEntry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 247: _t->insertBibEntry(); break;
        case 248: _t->setBibTypeFromAction(); break;
        case 249: _t->insertUserTag(); break;
        case 250: _t->execMacro((*reinterpret_cast<std::add_pointer_t<Macro>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MacroExecContext>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 251: _t->execMacro((*reinterpret_cast<std::add_pointer_t<Macro>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MacroExecContext>>(_a[2]))); break;
        case 252: _t->execMacro((*reinterpret_cast<std::add_pointer_t<Macro>>(_a[1]))); break;
        case 253: _t->runScript((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MacroExecContext>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 254: _t->runScript((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MacroExecContext>>(_a[2]))); break;
        case 255: _t->runScript((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 256: _t->editMacros(); break;
        case 257: _t->macroDialogAccepted(); break;
        case 258: _t->macroDialogRejected(); break;
        case 259: _t->insertRef((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 260: _t->insertRef(); break;
        case 261: _t->insertEqRef(); break;
        case 262: _t->insertPageRef(); break;
        case 263: _t->changeTextCodec(); break;
        case 264: _t->updateAvailableLanguages(); break;
        case 265: _t->updateLanguageToolStatus(); break;
        case 266: _t->editorSpellerChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 267: _t->changeEditorSpeller(); break;
        case 268: _t->showMoreDictionaries(); break;
        case 269: _t->insertSpellcheckMagicComment(); break;
        case 270: _t->updateStatusBarEncoding(); break;
        case 271: _t->addMagicRoot(); break;
        case 272: _t->addMagicCoding(); break;
        case 273: _t->addMagicBibliography(); break;
        case 274: _t->addMagicProgram(); break;
        case 275: _t->quickTabular((*reinterpret_cast<std::add_pointer_t<const QMimeData*>>(_a[1]))); break;
        case 276: _t->quickTabular(); break;
        case 277: _t->quickArray(); break;
        case 278: _t->quickTabbing(); break;
        case 279: _t->quickLetter(); break;
        case 280: _t->quickDocument(); break;
        case 281: _t->quickBeamer(); break;
        case 282: _t->quickGraphics((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 283: _t->quickGraphics(); break;
        case 284: _t->quickMath(); break;
        case 285: _t->aiChat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 286: _t->aiChat(); break;
        case 287: { bool _r = _t->checkProgramPermission((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 288: _t->runInternalPdfViewer((*reinterpret_cast<std::add_pointer_t<QFileInfo>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 289: _t->runBibliographyIfNecessary((*reinterpret_cast<std::add_pointer_t<QFileInfo>>(_a[1]))); break;
        case 290: { QDateTime _r = _t->GetBblLastModified();
            if (_a[0]) *reinterpret_cast<QDateTime*>(_a[0]) = std::move(_r); }  break;
        case 291: _t->showExtendedSearch(); break;
        case 292: _t->changeIconSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 293: _t->changeSecondaryIconSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 294: _t->changePDFIconSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 295: _t->changeSymbolGridIconSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 296: _t->changeSymbolGridIconSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 297: _t->connectSubCommand((*reinterpret_cast<std::add_pointer_t<ProcessX*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 298: _t->runInternalCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QFileInfo>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 299: _t->commandLineRequested((*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 300: _t->beginRunningCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 301: _t->beginRunningSubCommand((*reinterpret_cast<std::add_pointer_t<ProcessX*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<RunCommandFlags>>(_a[4]))); break;
        case 302: _t->endRunningSubCommand((*reinterpret_cast<std::add_pointer_t<ProcessX*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<RunCommandFlags>>(_a[4]))); break;
        case 303: _t->endRunningCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 304: { bool _r = _t->runCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QTextCodec*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 305: { bool _r = _t->runCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QTextCodec*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 306: { bool _r = _t->runCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 307: { bool _r = _t->runCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 308: { bool _r = _t->runCommandNoSpecialChars((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QTextCodec*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 309: { bool _r = _t->runCommandNoSpecialChars((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 310: { bool _r = _t->runCommandNoSpecialChars((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 311: _t->setStatusMessageProcess((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 312: { bool _r = _t->runCommandAsync((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 313: _t->processNotification((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 314: _t->clearLogs(); break;
        case 315: _t->openExternalTerminal(); break;
        case 316: _t->cleanAll(); break;
        case 317: _t->commandFromAction(); break;
        case 318: _t->webPublish(); break;
        case 319: _t->webPublishSource(); break;
        case 320: _t->convertToPlainText(); break;
        case 321: _t->analyseText(); break;
        case 322: _t->analyseTextFormDestroyed(); break;
        case 323: _t->generateRandomText(); break;
        case 324: _t->startCollabServer(); break;
        case 325: _t->connectCollabServer(); break;
        case 326: _t->disconnectCollabServer(); break;
        case 327: _t->updateCollabCursors((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 328: _t->removeCollabCursor((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 329: _t->removeAllCollabCursor((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 330: _t->updateCollabChanges((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 331: _t->updateCollaborationEditors((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5]))); break;
        case 332: { bool _r = _t->registerFileForCollab((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 333: _t->collabClientFinished((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 334: _t->guestServerSuccessfullyStarted(); break;
        case 335: _t->hostServerSuccessfullyStarted(); break;
        case 336: _t->updateCollabStatus(); break;
        case 337: _t->copyCollabLinkToClipboard(); break;
        case 338: { bool _r = _t->loadLog();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 339: _t->onCompileError(); break;
        case 340: _t->setLogMarksVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 341: _t->clearLogEntriesInEditors(); break;
        case 342: _t->updateLogEntriesInEditors(); break;
        case 343: _t->showLog(); break;
        case 344: _t->viewLog(); break;
        case 345: _t->viewLogOrReRun((*reinterpret_cast<std::add_pointer_t<LatexCompileResult*>>(_a[1]))); break;
        case 346: { bool _r = _t->gotoNearLogEntry((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 347: { bool _r = _t->hasLatexErrors();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 348: { bool _r = _t->logExists();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 349: _t->clearMarkers(); break;
        case 350: _t->latexHelp(); break;
        case 351: _t->userManualHelp(); break;
        case 352: _t->texdocHelp(); break;
        case 353: _t->helpAbout(); break;
        case 354: _t->generalOptions(); break;
        case 355: _t->setAutomaticRootDetection(); break;
        case 356: _t->setExplicitRootDocument((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 357: _t->setCurrentDocAsExplicitRoot(); break;
        case 358: _t->gotoNextDocument(); break;
        case 359: _t->gotoPrevDocument(); break;
        case 360: _t->gotoOpenDocument(); break;
        case 361: _t->updateOpenDocumentMenu((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 362: _t->updateOpenDocumentMenu(); break;
        case 363: _t->onEditorsReordered(); break;
        case 364: _t->focusEditor(); break;
        case 365: _t->focusViewer(); break;
        case 366: _t->enlargeEmbeddedPDFViewer(); break;
        case 367: _t->shrinkEmbeddedPDFViewer((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 368: _t->shrinkEmbeddedPDFViewer(); break;
        case 369: _t->setEnabledMenusEnlargeShrink((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 370: _t->showStatusbar(); break;
        case 371: _t->viewCloseElement(); break;
        case 372: _t->setFullScreenMode(); break;
        case 373: _t->viewSetHighlighting((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 374: _t->showHighlightingMenu(); break;
        case 375: _t->viewCollapseBlock(); break;
        case 376: _t->viewExpandBlock(); break;
        case 377: { QObject* _r = _t->newPdfPreviewer((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = std::move(_r); }  break;
        case 378: { QObject* _r = _t->newPdfPreviewer();
            if (_a[0]) *reinterpret_cast<QObject**>(_a[0]) = std::move(_r); }  break;
        case 379: _t->pdfClosed(); break;
        case 380: _t->masterDocumentChanged((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 381: _t->aboutToDeleteDocument((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1]))); break;
        case 382: _t->updateCompleter((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1]))); break;
        case 383: _t->updateCompleter(); break;
        case 384: _t->completerNeedsUpdate(); break;
        case 385: _t->completerCommandsNeedsUpdate(); break;
        case 386: _t->needUpdatedCompleter(); break;
        case 387: _t->outputPageChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 388: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QEditor::MoveFlags>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5]))); break;
        case 389: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QEditor::MoveFlags>>(_a[4]))); break;
        case 390: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[3]))); break;
        case 391: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 392: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 393: { bool _r = _t->gotoLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 394: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 395: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 396: _t->gotoLine((*reinterpret_cast<std::add_pointer_t<QTreeWidgetItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 397: _t->gotoLogEntryEditorOnly((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 398: { QDocumentCursor _r = _t->getLogEntryContextCursor((*reinterpret_cast<std::add_pointer_t<const QDocumentLineHandle*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LatexLogEntry>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDocumentCursor*>(_a[0]) = std::move(_r); }  break;
        case 399: { bool _r = _t->gotoLogEntryAt((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 400: { bool _r = _t->gotoMark((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 401: { bool _r = _t->gotoMark((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 402: { QList<int> _r = _t->findOccurencesApproximate((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QList<int>*>(_a[0]) = std::move(_r); }  break;
        case 403: _t->syncFromViewer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 404: _t->goBack(); break;
        case 405: _t->goForward(); break;
        case 406: _t->setGlobalCursor((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 407: _t->saveCurrentCursorToHistory(); break;
        case 408: _t->saveEditorCursorToHistory((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1]))); break;
        case 409: _t->previewLatex(); break;
        case 410: _t->previewAvailable((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<PreviewSource>>(_a[2]))); break;
        case 411: _t->clearPreview(); break;
        case 412: _t->showPreview((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 413: _t->showPreview((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 414: _t->showPreview((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 415: { QStringList _r = _t->makePreviewHeader((*reinterpret_cast<std::add_pointer_t<const LatexDocument*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 416: _t->showPreviewQueue(); break;
        case 417: _t->showImgPreview((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 418: _t->showImgPreviewFinished((*reinterpret_cast<std::add_pointer_t<QPixmap>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 419: _t->recompileForPreview(); break;
        case 420: _t->recompileForPreviewNow(); break;
        case 421: _t->templateEdit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 422: _t->fileReloaded(); break;
        case 423: _t->fileInConflictShowDiff(); break;
        case 424: _t->fileAutoReloading((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 425: _t->jumpToSearchResult((*reinterpret_cast<std::add_pointer_t<LatexDocument*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<const SearchQuery*>>(_a[3]))); break;
        case 426: _t->jumpToFileSearchResult((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<const SearchQuery*>>(_a[3]))); break;
        case 427: _t->cursorPositionChanged(); break;
        case 428: _t->syncPDFViewer((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 429: _t->syncPDFViewer((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 430: { bool _r = _t->generateMirror((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 431: { bool _r = _t->generateMirror();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 432: _t->generateBracketInverterMirror(); break;
        case 433: _t->jumpToBracket(); break;
        case 434: _t->selectBracket(); break;
        case 435: _t->findMissingBracket(); break;
        case 436: _t->cursorHovered(); break;
        case 437: _t->loadProfile(); break;
        case 438: _t->saveProfile(); break;
        case 439: _t->addRowCB(); break;
        case 440: _t->addColumnCB(); break;
        case 441: _t->removeColumnCB(); break;
        case 442: _t->removeRowCB(); break;
        case 443: _t->cutColumnCB(); break;
        case 444: _t->pasteColumnCB(); break;
        case 445: _t->addHLineCB(); break;
        case 446: _t->remHLineCB(); break;
        case 447: _t->insertTableTemplate(); break;
        case 448: _t->alignTableCols(); break;
        case 449: _t->updateTexQNFA(); break;
        case 450: _t->updateTexLikeQNFA((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 451: _t->toggleGrammar((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 452: _t->openInternalDocViewer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 453: _t->openInternalDocViewer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 454: _t->importPackage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 455: _t->packageScanCompleted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 456: _t->stopPackageParser(); break;
        case 457: _t->packageParserFinished(); break;
        case 458: _t->readinAllPackageNames(); break;
        case 459: _t->packageListReadCompleted((*reinterpret_cast<std::add_pointer_t<std::set<QString>>>(_a[1]))); break;
        case 460: _t->threadCrashed(); break;
        case 461: _t->iamalive(); break;
        case 462: _t->checkLatexInstall(); break;
        case 463: _t->checkCWLs(); break;
        case 464: _t->checkLanguageTool(); break;
        case 465: _t->slowOperationStarted(); break;
        case 466: _t->slowOperationEnded(); break;
        case 467: _t->openBugsAndFeatures(); break;
        case 468: _t->maniplateDockingTabBars(); break;
        case 469: _t->addDock((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[4]))); break;
        case 470: _t->toggleDocks((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 471: _t->resetDocks(); break;
        case 472: _t->toggleDockVisibility(); break;
        case 473: _t->updateDockVisibility((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 474: { bool _r = _t->checkDockSpread();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 475: { QString _r = _t->getCurrentFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 476: { 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 477: { 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 478: { QString _r = _t->getRelativeFileName((*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])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 479: { QString _r = _t->getRelativeFileName((*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 480: { bool _r = _t->fileExists((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 481: _t->runInternalCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 482: { QMenu* _r = _t->newManagedMenu((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QMenu**>(_a[0]) = std::move(_r); }  break;
        case 483: { QMenu* _r = _t->newManagedMenu((*reinterpret_cast<std::add_pointer_t<QMenu*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QMenu**>(_a[0]) = std::move(_r); }  break;
        case 484: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[7])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 485: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 486: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 487: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 488: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 489: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QKeySequence>>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[7])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 490: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QKeySequence>>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 491: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QKeySequence>>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 492: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[7])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 493: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 494: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 495: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 496: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 497: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QKeySequence>>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[7])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 498: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QKeySequence>>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 499: { QAction* _r = _t->newManagedEditorAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QList<QKeySequence>>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 500: { QAction* _r = _t->newManagedAction((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 501: { QMenu* _r = _t->getManagedMenu((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QMenu**>(_a[0]) = std::move(_r); }  break;
        case 502: { QAction* _r = _t->getManagedAction((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 503: { QList<QAction*> _r = _t->getManagedActions((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QList<QAction*>*>(_a[0]) = std::move(_r); }  break;
        case 504: { QList<QAction*> _r = _t->getManagedActions((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<QAction*>*>(_a[0]) = std::move(_r); }  break;
        case 505: { QAction* _r = _t->insertManagedAction((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 506: { QAction* _r = _t->insertManagedAction((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QKeySequence>>(_a[5])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 507: { QAction* _r = _t->insertManagedAction((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const char*>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 508: { QAction* _r = _t->insertManagedAction((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QAction**>(_a[0]) = std::move(_r); }  break;
        case 509: _t->loadManagedMenu((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 510: _t->setupToolBars(); break;
        case 511: { bool _r = _t->completerIsVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 512: { LatexEditorView* _r = _t->currentEditorView();
            if (_a[0]) *reinterpret_cast<LatexEditorView**>(_a[0]) = std::move(_r); }  break;
        case 513: { QEditor* _r = _t->currentEditor();
            if (_a[0]) *reinterpret_cast<QEditor**>(_a[0]) = std::move(_r); }  break;
        case 514: { QString _r = _t->clipboardText((*reinterpret_cast<std::add_pointer_t<QClipboard::Mode>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 515: { QString _r = _t->clipboardText();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 516: _t->setClipboardText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QClipboard::Mode>>(_a[2]))); break;
        case 517: _t->setClipboardText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 518: { int _r = _t->getVersion();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 519: _t->simulateKeyPress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 20:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 27:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 30:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 32:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StructureEntry* >(); break;
            }
            break;
        case 63:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<Macro> >(); break;
            }
            break;
        case 73:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QEditor* >(); break;
            }
            break;
        case 132:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QEditor* >(); break;
            }
            break;
        case 148:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 149:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 179:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 194:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< SearchQuery* >(); break;
            }
            break;
        case 195:
            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 196:
            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 210:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        case 217:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexEditorView* >(); break;
            }
            break;
        case 218:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 219:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 222:
            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 250:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Macro >(); break;
            }
            break;
        case 251:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Macro >(); break;
            }
            break;
        case 252:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Macro >(); break;
            }
            break;
        case 287:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexDocument* >(); break;
            }
            break;
        case 288:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFileInfo >(); break;
            }
            break;
        case 289:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFileInfo >(); break;
            }
            break;
        case 297:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ProcessX* >(); break;
            }
            break;
        case 298:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFileInfo >(); break;
            }
            break;
        case 301:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ProcessX* >(); break;
            }
            break;
        case 302:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ProcessX* >(); break;
            }
            break;
        case 327:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 328:
            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 330:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 356:
            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 373:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        case 380:
            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 381:
            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 382:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexEditorView* >(); break;
            }
            break;
        case 388:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexEditorView* >(); break;
            }
            break;
        case 389:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexEditorView* >(); break;
            }
            break;
        case 390:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexEditorView* >(); break;
            }
            break;
        case 394:
            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 395:
            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 406:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 408:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< LatexEditorView* >(); break;
            }
            break;
        case 413:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 414:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 425:
            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 428:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 429:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 469:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 3:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 483:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMenu* >(); break;
            }
            break;
        case 484:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 485:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 486:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 487:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 488:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 489:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 490:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 491:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 492:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 493:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 494:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 495:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 496:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 497:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 498:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 499:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 500:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 505:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        case 506:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        case 507:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        case 508:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)()>(_a, &Texstudio::infoNewFile, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)()>(_a, &Texstudio::infoNewFromTemplate, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)(const QString & )>(_a, &Texstudio::infoLoadFile, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)(const QString & , const int )>(_a, &Texstudio::infoFileSaved, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)()>(_a, &Texstudio::infoFileClosed, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)()>(_a, &Texstudio::infoAfterTypeset, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Texstudio::*)(const QString & )>(_a, &Texstudio::imgPreview, 7))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->clipboardText(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setClipboardText(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

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

// SIGNAL 2
void Texstudio::infoLoadFile(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Texstudio::infoFileSaved(const QString & _t1, const int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2);
}

// SIGNAL 5
void Texstudio::infoFileClosed()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

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

// SIGNAL 7
void Texstudio::imgPreview(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}
QT_WARNING_POP
