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

#include "../../../../lokalize-26.08.0/src/editortab.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto EditorTab::qt_create_metaobjectdata<qt_meta_tag_ZN9EditorTabE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EditorTab",
        "D-Bus Interface",
        "org.kde.Lokalize.Editor",
        "signalSelectGlossaryEntryRequested",
        "",
        "entryId",
        "tmLookupRequested",
        "DocPosition::Part",
        "source",
        "target",
        "srcFileOpenRequested",
        "srcPath",
        "line",
        "fileOpenRequested",
        "filePath",
        "str",
        "ctxt",
        "setAsActive",
        "fileClosed",
        "path",
        "fileSaved",
        "fileAboutToBeClosed",
        "fileOpened",
        "entryDisplayed",
        "signalNewEntryDisplayed",
        "DocPosition",
        "signalEntryWithMergeDisplayed",
        "signalFirstDisplayed",
        "signalLastDisplayed",
        "signalEquivTranslatedEntryDisplayed",
        "signalApprovedEntryDisplayed",
        "signalFuzzyEntryDisplayed",
        "signalPriorFuzzyAvailable",
        "signalNextFuzzyAvailable",
        "signalPriorUntranslatedAvailable",
        "signalNextUntranslatedAvailable",
        "signalPriorFuzzyOrUntrAvailable",
        "signalNextFuzzyOrUntrAvailable",
        "signalPriorBookmarkAvailable",
        "signalNextBookmarkAvailable",
        "signalBookmarkDisplayed",
        "signalSaveAllRequested",
        "signalRevertAllRequested",
        "signalCloseCurrentRequested",
        "signalCloseAllRequested",
        "signalActivateThisTabRequested",
        "QWidget*",
        "tabWidget",
        "xliffFileOpened",
        "signalDefineNewGlossaryTerm",
        "setProperFocus",
        "slotSelectGlossaryEntryRequested",
        "gotoEntry",
        "pos",
        "selection",
        "entry",
        "gotoEntryForm",
        "form",
        "gotoEntryFormOffset",
        "offset",
        "gotoEntryFormOffsetSelection",
        "currentEntryId",
        "currentEntry",
        "currentForm",
        "selectionInTarget",
        "selectionInSource",
        "setEntryFilteredOut",
        "filteredOut",
        "setEntriesFilteredOut",
        "entryCount",
        "entrySource",
        "entryTarget",
        "setEntryTarget",
        "content",
        "entryPluralFormCount",
        "entryReady",
        "addEntryNote",
        "note",
        "addTemporaryEntryNote",
        "addAlternateTranslation",
        "translation",
        "addTemporaryAlternateTranslation",
        "currentFile",
        "currentFileContents",
        "sourceLangCode",
        "targetLangCode",
        "attachAlternateTranslationFile",
        "openSyncSource",
        "reloadFile",
        "saveFile",
        "saveFileAs",
        "defaultPath",
        "close",
        "gotoNextUnfiltered",
        "gotoPrevUnfiltered",
        "gotoFirstUnfiltered",
        "gotoLastUnfiltered",
        "gotoNext",
        "gotoPrev",
        "gotoFirst",
        "gotoLast",
        "mergeIntoOpenDocument",
        "findEntryBySourceContext",
        "isValid",
        "setSrcFileOpenRequestAccepted",
        "a",
        "highlightFound",
        "highlightFound_",
        "lookupSelectionInTranslationMemory",
        "updateFirstOrLastDisplayed",
        "numberOfFuzziesChanged",
        "numberOfUntranslatedChanged",
        "msgStrChanged",
        "updateTabLabelAndIcon",
        "updateCaptionPath",
        "switchForm",
        "undo",
        "redo",
        "findNext",
        "findPrev",
        "find",
        "replace",
        "replaceNext",
        "doReplace",
        "cleanupReplace",
        "gotoPrevFuzzyUntr",
        "gotoNextFuzzyUntr",
        "gotoNextFuzzy",
        "gotoPrevFuzzy",
        "gotoNextUntranslated",
        "gotoPrevUntranslated",
        "toggleApprovementGotoNextFuzzyUntr",
        "setApproveActionTitle",
        "spellcheck",
        "spellcheckNext",
        "spellcheckShow",
        "spellcheckReplace",
        "spellcheckStop",
        "spellcheckCancel",
        "gotoNextBookmark",
        "gotoPrevBookmark",
        "editBookmarks",
        "displayWordCount",
        "clearTranslatedEntries",
        "launchPology",
        "openPhasesWindow",
        "defineNewTerm",
        "attachAlternateTranslationFileDialog",
        "initLater",
        "showStatesMenu",
        "setState",
        "QAction*",
        "dispatchSrcFileOpenRequest",
        "indexWordsForCompletion",
        "fileAutoSaveFailedWarning",
        "pologyHasFinished",
        "exitCode",
        "QProcess::ExitStatus",
        "exitStatus"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'signalSelectGlossaryEntryRequested'
        QtMocHelpers::SignalData<void(const QByteArray &)>(3, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 5 },
        }}),
        // Signal 'tmLookupRequested'
        QtMocHelpers::SignalData<void(DocPosition::Part, const QString &)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 4 }, { QMetaType::QString, 4 },
        }}),
        // Signal 'tmLookupRequested'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Signal 'srcFileOpenRequested'
        QtMocHelpers::SignalData<void(const QString &, int)>(10, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { QMetaType::Int, 12 },
        }}),
        // Signal 'fileOpenRequested'
        QtMocHelpers::SignalData<void(const QString &, const QString &, const QString &, const bool)>(13, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 }, { QMetaType::QString, 15 }, { QMetaType::QString, 16 }, { QMetaType::Bool, 17 },
        }}),
        // Signal 'fileClosed'
        QtMocHelpers::SignalData<void()>(18, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileClosed'
        QtMocHelpers::SignalData<void(const QString &)>(18, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 19 },
        }}),
        // Signal 'fileSaved'
        QtMocHelpers::SignalData<void(const QString &)>(20, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 19 },
        }}),
        // Signal 'fileAboutToBeClosed'
        QtMocHelpers::SignalData<void()>(21, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Signal 'fileOpened'
        QtMocHelpers::SignalData<void()>(22, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Signal 'entryDisplayed'
        QtMocHelpers::SignalData<void()>(23, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Signal 'signalNewEntryDisplayed'
        QtMocHelpers::SignalData<void(const DocPosition &)>(24, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 4 },
        }}),
        // Signal 'signalEntryWithMergeDisplayed'
        QtMocHelpers::SignalData<void(bool, const DocPosition &)>(26, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 }, { 0x80000000 | 25, 4 },
        }}),
        // Signal 'signalFirstDisplayed'
        QtMocHelpers::SignalData<void(bool)>(27, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalLastDisplayed'
        QtMocHelpers::SignalData<void(bool)>(28, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalEquivTranslatedEntryDisplayed'
        QtMocHelpers::SignalData<void(bool)>(29, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalApprovedEntryDisplayed'
        QtMocHelpers::SignalData<void(bool)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalFuzzyEntryDisplayed'
        QtMocHelpers::SignalData<void(bool)>(31, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalPriorFuzzyAvailable'
        QtMocHelpers::SignalData<void(bool)>(32, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalNextFuzzyAvailable'
        QtMocHelpers::SignalData<void(bool)>(33, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalPriorUntranslatedAvailable'
        QtMocHelpers::SignalData<void(bool)>(34, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalNextUntranslatedAvailable'
        QtMocHelpers::SignalData<void(bool)>(35, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalPriorFuzzyOrUntrAvailable'
        QtMocHelpers::SignalData<void(bool)>(36, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalNextFuzzyOrUntrAvailable'
        QtMocHelpers::SignalData<void(bool)>(37, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalPriorBookmarkAvailable'
        QtMocHelpers::SignalData<void(bool)>(38, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalNextBookmarkAvailable'
        QtMocHelpers::SignalData<void(bool)>(39, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalBookmarkDisplayed'
        QtMocHelpers::SignalData<void(bool)>(40, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalSaveAllRequested'
        QtMocHelpers::SignalData<void()>(41, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'signalRevertAllRequested'
        QtMocHelpers::SignalData<void()>(42, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'signalCloseCurrentRequested'
        QtMocHelpers::SignalData<void()>(43, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'signalCloseAllRequested'
        QtMocHelpers::SignalData<void()>(44, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'signalActivateThisTabRequested'
        QtMocHelpers::SignalData<void(QWidget *)>(45, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Signal 'xliffFileOpened'
        QtMocHelpers::SignalData<void(bool)>(48, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Signal 'signalDefineNewGlossaryTerm'
        QtMocHelpers::SignalData<void(QString, QString)>(49, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Slot 'setProperFocus'
        QtMocHelpers::SlotData<void()>(50, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSelectGlossaryEntryRequested'
        QtMocHelpers::SlotData<void(const QByteArray &)>(51, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 5 },
        }}),
        // Slot 'gotoEntry'
        QtMocHelpers::SlotData<void(DocPosition)>(52, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 53 },
        }}),
        // Slot 'gotoEntry'
        QtMocHelpers::SlotData<void(DocPosition, int)>(52, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 53 }, { QMetaType::Int, 54 },
        }}),
        // Slot 'gotoEntry'
        QtMocHelpers::SlotData<void(int)>(52, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 },
        }}),
        // Slot 'gotoEntryForm'
        QtMocHelpers::SlotData<void(int, int)>(56, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::Int, 57 },
        }}),
        // Slot 'gotoEntryFormOffset'
        QtMocHelpers::SlotData<void(int, int, int)>(58, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::Int, 57 }, { QMetaType::Int, 59 },
        }}),
        // Slot 'gotoEntryFormOffsetSelection'
        QtMocHelpers::SlotData<void(int, int, int, int)>(60, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::Int, 57 }, { QMetaType::Int, 59 }, { QMetaType::Int, 54 },
        }}),
        // Slot 'currentEntryId'
        QtMocHelpers::SlotData<QString()>(61, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Slot 'currentEntry'
        QtMocHelpers::SlotData<int()>(62, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Int),
        // Slot 'currentForm'
        QtMocHelpers::SlotData<int()>(63, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Int),
        // Slot 'selectionInTarget'
        QtMocHelpers::SlotData<QString()>(64, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Slot 'selectionInSource'
        QtMocHelpers::SlotData<QString()>(65, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Slot 'setEntryFilteredOut'
        QtMocHelpers::SlotData<void(int, bool)>(66, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::Bool, 67 },
        }}),
        // Slot 'setEntriesFilteredOut'
        QtMocHelpers::SlotData<void(bool)>(68, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 67 },
        }}),
        // Slot 'entryCount'
        QtMocHelpers::SlotData<int()>(69, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Int),
        // Slot 'entrySource'
        QtMocHelpers::SlotData<QString(int, int)>(70, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString, {{
            { QMetaType::Int, 55 }, { QMetaType::Int, 57 },
        }}),
        // Slot 'entryTarget'
        QtMocHelpers::SlotData<QString(int, int)>(71, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString, {{
            { QMetaType::Int, 55 }, { QMetaType::Int, 57 },
        }}),
        // Slot 'setEntryTarget'
        QtMocHelpers::SlotData<void(int, int, const QString &)>(72, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::Int, 57 }, { QMetaType::QString, 73 },
        }}),
        // Slot 'entryPluralFormCount'
        QtMocHelpers::SlotData<int(int)>(74, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Int, {{
            { QMetaType::Int, 55 },
        }}),
        // Slot 'entryReady'
        QtMocHelpers::SlotData<bool(int)>(75, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::Int, 55 },
        }}),
        // Slot 'addEntryNote'
        QtMocHelpers::SlotData<void(int, const QString &)>(76, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::QString, 77 },
        }}),
        // Slot 'addTemporaryEntryNote'
        QtMocHelpers::SlotData<void(int, const QString &)>(78, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::QString, 77 },
        }}),
        // Slot 'addAlternateTranslation'
        QtMocHelpers::SlotData<void(int, const QString &)>(79, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::QString, 80 },
        }}),
        // Slot 'addTemporaryAlternateTranslation'
        QtMocHelpers::SlotData<void(int, const QString &)>(81, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Int, 55 }, { QMetaType::QString, 80 },
        }}),
        // Slot 'currentFile'
        QtMocHelpers::SlotData<QString()>(82, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Slot 'currentFileContents'
        QtMocHelpers::SlotData<QByteArray()>(83, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QByteArray),
        // Slot 'sourceLangCode'
        QtMocHelpers::SlotData<QString()>(84, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Slot 'targetLangCode'
        QtMocHelpers::SlotData<QString()>(85, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Slot 'attachAlternateTranslationFile'
        QtMocHelpers::SlotData<void(const QString &)>(86, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 19 },
        }}),
        // Slot 'openSyncSource'
        QtMocHelpers::SlotData<void(QString)>(87, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 19 },
        }}),
        // Slot 'reloadFile'
        QtMocHelpers::SlotData<void()>(88, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'saveFile'
        QtMocHelpers::SlotData<bool(const QString &)>(89, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::QString, 14 },
        }}),
        // Slot 'saveFile'
        QtMocHelpers::SlotData<bool()>(89, 4, QMC::AccessPublic | QMC::MethodCloned | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'saveFileAs'
        QtMocHelpers::SlotData<bool(const QString &)>(90, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::QString, 91 },
        }}),
        // Slot 'saveFileAs'
        QtMocHelpers::SlotData<bool()>(90, 4, QMC::AccessPublic | QMC::MethodCloned | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'close'
        QtMocHelpers::SlotData<void()>(92, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoNextUnfiltered'
        QtMocHelpers::SlotData<void()>(93, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoPrevUnfiltered'
        QtMocHelpers::SlotData<void()>(94, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoFirstUnfiltered'
        QtMocHelpers::SlotData<void()>(95, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoLastUnfiltered'
        QtMocHelpers::SlotData<void()>(96, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoNext'
        QtMocHelpers::SlotData<void()>(97, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoPrev'
        QtMocHelpers::SlotData<void()>(98, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoFirst'
        QtMocHelpers::SlotData<void()>(99, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'gotoLast'
        QtMocHelpers::SlotData<void()>(100, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'mergeIntoOpenDocument'
        QtMocHelpers::SlotData<void()>(101, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'findEntryBySourceContext'
        QtMocHelpers::SlotData<bool(const QString &, const QString &)>(102, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 16 },
        }}),
        // Slot 'isValid'
        QtMocHelpers::SlotData<bool()>(103, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'setSrcFileOpenRequestAccepted'
        QtMocHelpers::SlotData<void(bool)>(104, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 105 },
        }}),
        // Slot 'highlightFound'
        QtMocHelpers::SlotData<void(const QString &, int, int)>(106, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 }, { QMetaType::Int, 4 }, { QMetaType::Int, 4 },
        }}),
        // Slot 'highlightFound_'
        QtMocHelpers::SlotData<void(const QString &, int, int)>(107, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 }, { QMetaType::Int, 4 }, { QMetaType::Int, 4 },
        }}),
        // Slot 'lookupSelectionInTranslationMemory'
        QtMocHelpers::SlotData<void()>(108, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateFirstOrLastDisplayed'
        QtMocHelpers::SlotData<void()>(109, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'numberOfFuzziesChanged'
        QtMocHelpers::SlotData<void()>(110, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'numberOfUntranslatedChanged'
        QtMocHelpers::SlotData<void()>(111, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'msgStrChanged'
        QtMocHelpers::SlotData<void()>(112, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateTabLabelAndIcon'
        QtMocHelpers::SlotData<void()>(113, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateCaptionPath'
        QtMocHelpers::SlotData<void()>(114, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'switchForm'
        QtMocHelpers::SlotData<void(int)>(115, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 4 },
        }}),
        // Slot 'undo'
        QtMocHelpers::SlotData<void()>(116, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'redo'
        QtMocHelpers::SlotData<void()>(117, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'findNext'
        QtMocHelpers::SlotData<void()>(118, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'findPrev'
        QtMocHelpers::SlotData<void()>(119, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'find'
        QtMocHelpers::SlotData<void()>(120, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'replace'
        QtMocHelpers::SlotData<void()>(121, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'replaceNext'
        QtMocHelpers::SlotData<void()>(122, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'doReplace'
        QtMocHelpers::SlotData<void(const QString &, int, int, int)>(123, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 }, { QMetaType::Int, 4 }, { QMetaType::Int, 4 }, { QMetaType::Int, 4 },
        }}),
        // Slot 'cleanupReplace'
        QtMocHelpers::SlotData<void()>(124, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoEntry'
        QtMocHelpers::SlotData<void()>(52, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoPrevFuzzyUntr'
        QtMocHelpers::SlotData<bool()>(125, 4, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'gotoPrevFuzzyUntr'
        QtMocHelpers::SlotData<bool(const DocPosition &)>(125, 4, QMC::AccessPrivate, QMetaType::Bool, {{
            { 0x80000000 | 25, 53 },
        }}),
        // Slot 'gotoNextFuzzyUntr'
        QtMocHelpers::SlotData<bool(const DocPosition &)>(126, 4, QMC::AccessPrivate, QMetaType::Bool, {{
            { 0x80000000 | 25, 53 },
        }}),
        // Slot 'gotoNextFuzzyUntr'
        QtMocHelpers::SlotData<bool()>(126, 4, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'gotoNextFuzzy'
        QtMocHelpers::SlotData<void()>(127, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoPrevFuzzy'
        QtMocHelpers::SlotData<void()>(128, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoNextUntranslated'
        QtMocHelpers::SlotData<void()>(129, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoPrevUntranslated'
        QtMocHelpers::SlotData<void()>(130, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'toggleApprovementGotoNextFuzzyUntr'
        QtMocHelpers::SlotData<void()>(131, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setApproveActionTitle'
        QtMocHelpers::SlotData<void()>(132, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'spellcheck'
        QtMocHelpers::SlotData<void()>(133, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'spellcheckNext'
        QtMocHelpers::SlotData<void()>(134, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'spellcheckShow'
        QtMocHelpers::SlotData<void(const QString &, int)>(135, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 }, { QMetaType::Int, 4 },
        }}),
        // Slot 'spellcheckReplace'
        QtMocHelpers::SlotData<void(QString, int, const QString &)>(136, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 }, { QMetaType::Int, 4 }, { QMetaType::QString, 4 },
        }}),
        // Slot 'spellcheckStop'
        QtMocHelpers::SlotData<void()>(137, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'spellcheckCancel'
        QtMocHelpers::SlotData<void()>(138, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoNextBookmark'
        QtMocHelpers::SlotData<void()>(139, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'gotoPrevBookmark'
        QtMocHelpers::SlotData<void()>(140, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'editBookmarks'
        QtMocHelpers::SlotData<void()>(141, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'displayWordCount'
        QtMocHelpers::SlotData<void()>(142, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'clearTranslatedEntries'
        QtMocHelpers::SlotData<void()>(143, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'launchPology'
        QtMocHelpers::SlotData<void()>(144, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'openPhasesWindow'
        QtMocHelpers::SlotData<void()>(145, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'defineNewTerm'
        QtMocHelpers::SlotData<void()>(146, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'attachAlternateTranslationFileDialog'
        QtMocHelpers::SlotData<void()>(147, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'initLater'
        QtMocHelpers::SlotData<void()>(148, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'showStatesMenu'
        QtMocHelpers::SlotData<void()>(149, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setState'
        QtMocHelpers::SlotData<void(QAction *)>(150, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 151, 4 },
        }}),
        // Slot 'dispatchSrcFileOpenRequest'
        QtMocHelpers::SlotData<void(const QString &, int)>(152, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { QMetaType::Int, 12 },
        }}),
        // Slot 'indexWordsForCompletion'
        QtMocHelpers::SlotData<void()>(153, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'fileAutoSaveFailedWarning'
        QtMocHelpers::SlotData<void(const QString &)>(154, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'pologyHasFinished'
        QtMocHelpers::SlotData<void(int, QProcess::ExitStatus)>(155, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 156 }, { 0x80000000 | 157, 158 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<EditorTab, qt_meta_tag_ZN9EditorTabE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject EditorTab::staticMetaObject = { {
    QMetaObject::SuperData::link<LokalizeTabPageBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9EditorTabE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9EditorTabE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9EditorTabE_t>.metaTypes,
    nullptr
} };

void EditorTab::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<EditorTab *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->signalSelectGlossaryEntryRequested((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 1: _t->tmLookupRequested((*reinterpret_cast<std::add_pointer_t<DocPosition::Part>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 2: _t->tmLookupRequested((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 3: _t->srcFileOpenRequested((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 4: _t->fileOpenRequested((*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<bool>>(_a[4]))); break;
        case 5: _t->fileClosed(); break;
        case 6: _t->fileClosed((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->fileSaved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: _t->fileAboutToBeClosed(); break;
        case 9: _t->fileOpened(); break;
        case 10: _t->entryDisplayed(); break;
        case 11: _t->signalNewEntryDisplayed((*reinterpret_cast<std::add_pointer_t<DocPosition>>(_a[1]))); break;
        case 12: _t->signalEntryWithMergeDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<DocPosition>>(_a[2]))); break;
        case 13: _t->signalFirstDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->signalLastDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->signalEquivTranslatedEntryDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->signalApprovedEntryDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->signalFuzzyEntryDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->signalPriorFuzzyAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->signalNextFuzzyAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->signalPriorUntranslatedAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->signalNextUntranslatedAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->signalPriorFuzzyOrUntrAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 23: _t->signalNextFuzzyOrUntrAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->signalPriorBookmarkAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 25: _t->signalNextBookmarkAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 26: _t->signalBookmarkDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->signalSaveAllRequested(); break;
        case 28: _t->signalRevertAllRequested(); break;
        case 29: _t->signalCloseCurrentRequested(); break;
        case 30: _t->signalCloseAllRequested(); break;
        case 31: _t->signalActivateThisTabRequested((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1]))); break;
        case 32: _t->xliffFileOpened((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->signalDefineNewGlossaryTerm((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 34: _t->setProperFocus(); break;
        case 35: _t->slotSelectGlossaryEntryRequested((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 36: _t->gotoEntry((*reinterpret_cast<std::add_pointer_t<DocPosition>>(_a[1]))); break;
        case 37: _t->gotoEntry((*reinterpret_cast<std::add_pointer_t<DocPosition>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 38: _t->gotoEntry((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 39: _t->gotoEntryForm((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 40: _t->gotoEntryFormOffset((*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]))); break;
        case 41: _t->gotoEntryFormOffsetSelection((*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]))); break;
        case 42: { QString _r = _t->currentEntryId();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 43: { int _r = _t->currentEntry();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 44: { int _r = _t->currentForm();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 45: { QString _r = _t->selectionInTarget();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 46: { QString _r = _t->selectionInSource();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 47: _t->setEntryFilteredOut((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 48: _t->setEntriesFilteredOut((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 49: { int _r = _t->entryCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 50: { QString _r = _t->entrySource((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 51: { QString _r = _t->entryTarget((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 52: _t->setEntryTarget((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 53: { int _r = _t->entryPluralFormCount((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 54: { bool _r = _t->entryReady((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 55: _t->addEntryNote((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 56: _t->addTemporaryEntryNote((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 57: _t->addAlternateTranslation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 58: _t->addTemporaryAlternateTranslation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 59: { QString _r = _t->currentFile();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 60: { QByteArray _r = _t->currentFileContents();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 61: { QString _r = _t->sourceLangCode();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 62: { QString _r = _t->targetLangCode();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 63: _t->attachAlternateTranslationFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 64: _t->openSyncSource((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->reloadFile(); break;
        case 66: { bool _r = _t->saveFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 67: { bool _r = _t->saveFile();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 68: { bool _r = _t->saveFileAs((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 69: { bool _r = _t->saveFileAs();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: _t->close(); break;
        case 71: _t->gotoNextUnfiltered(); break;
        case 72: _t->gotoPrevUnfiltered(); break;
        case 73: _t->gotoFirstUnfiltered(); break;
        case 74: _t->gotoLastUnfiltered(); break;
        case 75: _t->gotoNext(); break;
        case 76: _t->gotoPrev(); break;
        case 77: _t->gotoFirst(); break;
        case 78: _t->gotoLast(); break;
        case 79: _t->mergeIntoOpenDocument(); break;
        case 80: { bool _r = _t->findEntryBySourceContext((*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 81: { bool _r = _t->isValid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 82: _t->setSrcFileOpenRequestAccepted((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 83: _t->highlightFound((*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 84: _t->highlightFound_((*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 85: _t->lookupSelectionInTranslationMemory(); break;
        case 86: _t->updateFirstOrLastDisplayed(); break;
        case 87: _t->numberOfFuzziesChanged(); break;
        case 88: _t->numberOfUntranslatedChanged(); break;
        case 89: _t->msgStrChanged(); break;
        case 90: _t->updateTabLabelAndIcon(); break;
        case 91: _t->updateCaptionPath(); break;
        case 92: _t->switchForm((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 93: _t->undo(); break;
        case 94: _t->redo(); break;
        case 95: _t->findNext(); break;
        case 96: _t->findPrev(); break;
        case 97: _t->find(); break;
        case 98: _t->replace(); break;
        case 99: _t->replaceNext(); break;
        case 100: _t->doReplace((*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->cleanupReplace(); break;
        case 102: _t->gotoEntry(); break;
        case 103: { bool _r = _t->gotoPrevFuzzyUntr();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 104: { bool _r = _t->gotoPrevFuzzyUntr((*reinterpret_cast<std::add_pointer_t<DocPosition>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 105: { bool _r = _t->gotoNextFuzzyUntr((*reinterpret_cast<std::add_pointer_t<DocPosition>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 106: { bool _r = _t->gotoNextFuzzyUntr();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 107: _t->gotoNextFuzzy(); break;
        case 108: _t->gotoPrevFuzzy(); break;
        case 109: _t->gotoNextUntranslated(); break;
        case 110: _t->gotoPrevUntranslated(); break;
        case 111: _t->toggleApprovementGotoNextFuzzyUntr(); break;
        case 112: _t->setApproveActionTitle(); break;
        case 113: _t->spellcheck(); break;
        case 114: _t->spellcheckNext(); break;
        case 115: _t->spellcheckShow((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 116: _t->spellcheckReplace((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 117: _t->spellcheckStop(); break;
        case 118: _t->spellcheckCancel(); break;
        case 119: _t->gotoNextBookmark(); break;
        case 120: _t->gotoPrevBookmark(); break;
        case 121: _t->editBookmarks(); break;
        case 122: _t->displayWordCount(); break;
        case 123: _t->clearTranslatedEntries(); break;
        case 124: _t->launchPology(); break;
        case 125: _t->openPhasesWindow(); break;
        case 126: _t->defineNewTerm(); break;
        case 127: _t->attachAlternateTranslationFileDialog(); break;
        case 128: _t->initLater(); break;
        case 129: _t->showStatesMenu(); break;
        case 130: _t->setState((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 131: _t->dispatchSrcFileOpenRequest((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 132: _t->indexWordsForCompletion(); break;
        case 133: _t->fileAutoSaveFailedWarning((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 134: _t->pologyHasFinished((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QProcess::ExitStatus>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DocPosition >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DocPosition >(); break;
            }
            break;
        case 31:
            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 36:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DocPosition >(); break;
            }
            break;
        case 37:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DocPosition >(); break;
            }
            break;
        case 104:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DocPosition >(); break;
            }
            break;
        case 105:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DocPosition >(); break;
            }
            break;
        case 130:
            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 (EditorTab::*)(const QByteArray & )>(_a, &EditorTab::signalSelectGlossaryEntryRequested, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(DocPosition::Part , const QString & )>(_a, &EditorTab::tmLookupRequested, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(const QString & , const QString & )>(_a, &EditorTab::tmLookupRequested, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(const QString & , int )>(_a, &EditorTab::srcFileOpenRequested, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(const QString & , const QString & , const QString & , const bool )>(_a, &EditorTab::fileOpenRequested, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::fileClosed, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(const QString & )>(_a, &EditorTab::fileClosed, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(const QString & )>(_a, &EditorTab::fileSaved, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::fileAboutToBeClosed, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::fileOpened, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::entryDisplayed, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(const DocPosition & )>(_a, &EditorTab::signalNewEntryDisplayed, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool , const DocPosition & )>(_a, &EditorTab::signalEntryWithMergeDisplayed, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalFirstDisplayed, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalLastDisplayed, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalEquivTranslatedEntryDisplayed, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalApprovedEntryDisplayed, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalFuzzyEntryDisplayed, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalPriorFuzzyAvailable, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalNextFuzzyAvailable, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalPriorUntranslatedAvailable, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalNextUntranslatedAvailable, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalPriorFuzzyOrUntrAvailable, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalNextFuzzyOrUntrAvailable, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalPriorBookmarkAvailable, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalNextBookmarkAvailable, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::signalBookmarkDisplayed, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::signalSaveAllRequested, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::signalRevertAllRequested, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::signalCloseCurrentRequested, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)()>(_a, &EditorTab::signalCloseAllRequested, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(QWidget * )>(_a, &EditorTab::signalActivateThisTabRequested, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(bool )>(_a, &EditorTab::xliffFileOpened, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorTab::*)(QString , QString )>(_a, &EditorTab::signalDefineNewGlossaryTerm, 33))
            return;
    }
}

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

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

int EditorTab::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = LokalizeTabPageBase::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 135)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 135;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 135)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 135;
    }
    return _id;
}

// SIGNAL 0
void EditorTab::signalSelectGlossaryEntryRequested(const QByteArray & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void EditorTab::tmLookupRequested(DocPosition::Part _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

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

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

// SIGNAL 4
void EditorTab::fileOpenRequested(const QString & _t1, const QString & _t2, const QString & _t3, const bool _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2, _t3, _t4);
}

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

// SIGNAL 6
void EditorTab::fileClosed(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

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

// SIGNAL 8
void EditorTab::fileAboutToBeClosed()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void EditorTab::fileOpened()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void EditorTab::entryDisplayed()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void EditorTab::signalNewEntryDisplayed(const DocPosition & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void EditorTab::signalEntryWithMergeDisplayed(bool _t1, const DocPosition & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void EditorTab::signalFirstDisplayed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void EditorTab::signalLastDisplayed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void EditorTab::signalEquivTranslatedEntryDisplayed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void EditorTab::signalApprovedEntryDisplayed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void EditorTab::signalFuzzyEntryDisplayed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void EditorTab::signalPriorFuzzyAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void EditorTab::signalNextFuzzyAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void EditorTab::signalPriorUntranslatedAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void EditorTab::signalNextUntranslatedAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void EditorTab::signalPriorFuzzyOrUntrAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void EditorTab::signalNextFuzzyOrUntrAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void EditorTab::signalPriorBookmarkAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void EditorTab::signalNextBookmarkAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void EditorTab::signalBookmarkDisplayed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void EditorTab::signalSaveAllRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void EditorTab::signalRevertAllRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

// SIGNAL 29
void EditorTab::signalCloseCurrentRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 29, nullptr);
}

// SIGNAL 30
void EditorTab::signalCloseAllRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}

// SIGNAL 31
void EditorTab::signalActivateThisTabRequested(QWidget * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void EditorTab::xliffFileOpened(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void EditorTab::signalDefineNewGlossaryTerm(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1, _t2);
}
QT_WARNING_POP
