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

#include "../../../texstudio-4.9.5/src/qcodeedit/lib/qeditor.h"
#include <QtGui/qtextcursor.h>
#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 'qeditor.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto QEditor::qt_create_metaobjectdata<qt_meta_tag_ZN7QEditorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QEditor",
        "loaded",
        "",
        "QEditor*",
        "e",
        "s",
        "saved",
        "contentModified",
        "y",
        "readOnlyChanged",
        "titleChanged",
        "title",
        "focusReceived",
        "textEdited",
        "QKeyEvent*",
        "cursorPositionChanged",
        "copyAvailable",
        "undoAvailable",
        "redoAvailable",
        "markChanged",
        "f",
        "QDocumentLineHandle*",
        "l",
        "mark",
        "on",
        "hovered",
        "QPoint",
        "pos",
        "fileReloaded",
        "fileInConflict",
        "fileInConflictShowDiff",
        "fileAutoReloading",
        "fname",
        "needUpdatedCompleter",
        "requestClose",
        "cursorHovered",
        "emitWordDoubleClicked",
        "visibleLinesChanged",
        "slowOperationStarted",
        "slowOperationEnded",
        "undo",
        "redo",
        "cut",
        "copy",
        "paste",
        "selectAll",
        "selectNothing",
        "selectExpand",
        "QDocumentCursor::SelectionType",
        "selectionType",
        "selectExpandToNextWord",
        "selectExpandToNextLine",
        "selectAllOccurences",
        "selectNextOccurence",
        "selectPrevOccurence",
        "selectNextOccurenceKeepMirror",
        "selectPrevOccurenceKeepMirror",
        "selectOccurence",
        "backward",
        "keepMirrors",
        "all",
        "relayPanelCommand",
        "panel",
        "command",
        "QList<QVariant>",
        "args",
        "find",
        "text",
        "highlight",
        "regex",
        "word",
        "caseSensitive",
        "fromCursor",
        "selection",
        "findInSameDir",
        "findNext",
        "findPrev",
        "findCount",
        "selectAllMatches",
        "replacePanel",
        "replaceNext",
        "replacePrev",
        "replaceAll",
        "gotoLine",
        "tabOrIndentSelection",
        "insertTab",
        "indentSelection",
        "unindentSelection",
        "commentSelection",
        "uncommentSelection",
        "toggleCommentSelection",
        "setLineWrapping",
        "setHardLineWrapping",
        "setSoftLimitedLineWrapping",
        "setWrapAfterNumChars",
        "numChars",
        "print",
        "retranslate",
        "write",
        "addAction",
        "QAction*",
        "a",
        "menu",
        "toolbar",
        "removeAction",
        "load",
        "file",
        "QTextCodec*",
        "codec",
        "skipHighlight",
        "reload",
        "setText",
        "allowUndo",
        "setDocument",
        "QDocument*",
        "d",
        "addInputBinding",
        "QEditorInputBindingInterface*",
        "b",
        "removeInputBinding",
        "setInputBinding",
        "setCursor",
        "QDocumentCursor",
        "c",
        "moveView",
        "setLanguageDefinition",
        "QLanguageDefinition*",
        "setCompletionEngine",
        "QCodeCompletionEngine*",
        "zoomIn",
        "zoomOut",
        "resetZoom",
        "zoom",
        "n",
        "setPanelMargins",
        "t",
        "r",
        "getPanelMargins",
        "qreal*",
        "setTitle",
        "clearPlaceHolders",
        "addPlaceHolder",
        "PlaceHolder",
        "p",
        "autoUpdate",
        "addPlaceHolderMirror",
        "placeHolderId",
        "removePlaceHolder",
        "id",
        "replacePlaceHolders",
        "QList<PlaceHolder>",
        "newPlaceholders",
        "placeHolderCount",
        "currentPlaceHolder",
        "getPlaceHolder",
        "i",
        "getPlaceHolders",
        "isAutoOverrideText",
        "resizeAutoOverridenPlaceholder",
        "start",
        "length",
        "nextPlaceHolder",
        "previousPlaceHolder",
        "setPlaceHolder",
        "selectCursors",
        "setFileName",
        "checkClipboard",
        "reconnectWatcher",
        "disconnectWatcher",
        "fileChanged",
        "setContentClean",
        "emitCursorPositionChanged",
        "ensureCursorVisible",
        "cursor",
        "MoveFlags",
        "mflags",
        "setContentModified",
        "emitNeedUpdatedCompleter",
        "pageUp",
        "QDocumentCursor::MoveMode",
        "moveMode",
        "pageDown",
        "repaintCursor",
        "ensureVisible",
        "line",
        "QRectF",
        "rect",
        "insertText",
        "QDocumentCursor&",
        "documentWidthChanged",
        "newWidth",
        "documentHeightChanged",
        "repaintContent",
        "updateContent",
        "bindingSelected",
        "lineEndingSelected",
        "lineEndingChanged",
        "lineEnding",
        "canUndo",
        "canRedo",
        "document",
        "isCursorVisible",
        "cursorMirrorCount",
        "cursorMirror",
        "cursors",
        "QList<QDocumentCursor>",
        "scrollToFirstLine",
        "name",
        "fileName",
        "fileInfo",
        "QFileInfo",
        "isReadOnly",
        "setReadOnly",
        "isContentModified",
        "isInConflict",
        "getFileCodec",
        "setFileCodec",
        "clearCursorMirrors",
        "addCursorMirror",
        "cursorMirrorsRemoveSelectedText"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loaded'
        QtMocHelpers::SignalData<void(QEditor *, const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::QString, 5 },
        }}),
        // Signal 'saved'
        QtMocHelpers::SignalData<void(QEditor *, const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::QString, 5 },
        }}),
        // Signal 'contentModified'
        QtMocHelpers::SignalData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'readOnlyChanged'
        QtMocHelpers::SignalData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'titleChanged'
        QtMocHelpers::SignalData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Signal 'focusReceived'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'textEdited'
        QtMocHelpers::SignalData<void(QKeyEvent *)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 14, 4 },
        }}),
        // Signal 'cursorPositionChanged'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'copyAvailable'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'undoAvailable'
        QtMocHelpers::SignalData<void(bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'redoAvailable'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'markChanged'
        QtMocHelpers::SignalData<void(const QString &, QDocumentLineHandle *, int, bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 }, { 0x80000000 | 21, 22 }, { QMetaType::Int, 23 }, { QMetaType::Bool, 24 },
        }}),
        // Signal 'hovered'
        QtMocHelpers::SignalData<void(QPoint)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Signal 'fileReloaded'
        QtMocHelpers::SignalData<void()>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileInConflict'
        QtMocHelpers::SignalData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileInConflictShowDiff'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileAutoReloading'
        QtMocHelpers::SignalData<void(QString)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 32 },
        }}),
        // Signal 'needUpdatedCompleter'
        QtMocHelpers::SignalData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'requestClose'
        QtMocHelpers::SignalData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cursorHovered'
        QtMocHelpers::SignalData<void()>(35, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'emitWordDoubleClicked'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'visibleLinesChanged'
        QtMocHelpers::SignalData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'slowOperationStarted'
        QtMocHelpers::SignalData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'slowOperationEnded'
        QtMocHelpers::SignalData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'undo'
        QtMocHelpers::SlotData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'redo'
        QtMocHelpers::SlotData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'cut'
        QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'copy'
        QtMocHelpers::SlotData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'paste'
        QtMocHelpers::SlotData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectAll'
        QtMocHelpers::SlotData<void()>(45, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectNothing'
        QtMocHelpers::SlotData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectExpand'
        QtMocHelpers::SlotData<void(QDocumentCursor::SelectionType)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'selectExpandToNextWord'
        QtMocHelpers::SlotData<void()>(50, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectExpandToNextLine'
        QtMocHelpers::SlotData<void()>(51, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectAllOccurences'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectNextOccurence'
        QtMocHelpers::SlotData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectPrevOccurence'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectNextOccurenceKeepMirror'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectPrevOccurenceKeepMirror'
        QtMocHelpers::SlotData<void()>(56, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectOccurence'
        QtMocHelpers::SlotData<void(bool, bool, bool)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 58 }, { QMetaType::Bool, 59 }, { QMetaType::Bool, 60 },
        }}),
        // Slot 'relayPanelCommand'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QList<QVariant> &)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 62 }, { QMetaType::QString, 63 }, { 0x80000000 | 64, 65 },
        }}),
        // Slot 'relayPanelCommand'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(61, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 62 }, { QMetaType::QString, 63 },
        }}),
        // Slot 'find'
        QtMocHelpers::SlotData<void()>(66, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'find'
        QtMocHelpers::SlotData<void(QString, bool, bool, bool, bool)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 67 }, { QMetaType::Bool, 68 }, { QMetaType::Bool, 69 }, { QMetaType::Bool, 70 },
            { QMetaType::Bool, 71 },
        }}),
        // Slot 'find'
        QtMocHelpers::SlotData<void(QString, bool, bool, bool)>(66, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 67 }, { QMetaType::Bool, 68 }, { QMetaType::Bool, 69 }, { QMetaType::Bool, 70 },
        }}),
        // Slot 'find'
        QtMocHelpers::SlotData<void(QString, bool, bool)>(66, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 67 }, { QMetaType::Bool, 68 }, { QMetaType::Bool, 69 },
        }}),
        // Slot 'find'
        QtMocHelpers::SlotData<void(QString, bool, bool, bool, bool, bool, bool)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 67 }, { QMetaType::Bool, 68 }, { QMetaType::Bool, 69 }, { QMetaType::Bool, 70 },
            { QMetaType::Bool, 71 }, { QMetaType::Bool, 72 }, { QMetaType::Bool, 73 },
        }}),
        // Slot 'findInSameDir'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'findNext'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'findPrev'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'findCount'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectAllMatches'
        QtMocHelpers::SlotData<void()>(78, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'replacePanel'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'replaceNext'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'replacePrev'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'replaceAll'
        QtMocHelpers::SlotData<void()>(82, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'gotoLine'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'tabOrIndentSelection'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'insertTab'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'indentSelection'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'unindentSelection'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'commentSelection'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'uncommentSelection'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleCommentSelection'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setLineWrapping'
        QtMocHelpers::SlotData<void(bool)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 24 },
        }}),
        // Slot 'setHardLineWrapping'
        QtMocHelpers::SlotData<void(bool)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 24 },
        }}),
        // Slot 'setSoftLimitedLineWrapping'
        QtMocHelpers::SlotData<void(bool)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 24 },
        }}),
        // Slot 'setWrapAfterNumChars'
        QtMocHelpers::SlotData<void(int)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 95 },
        }}),
        // Slot 'print'
        QtMocHelpers::SlotData<void()>(96, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'retranslate'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'write'
        QtMocHelpers::SlotData<void(const QString &)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'addAction'
        QtMocHelpers::SlotData<void(QAction *, const QString &, const QString &)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 100, 101 }, { QMetaType::QString, 102 }, { QMetaType::QString, 103 },
        }}),
        // Slot 'addAction'
        QtMocHelpers::SlotData<void(QAction *, const QString &)>(99, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 100, 101 }, { QMetaType::QString, 102 },
        }}),
        // Slot 'removeAction'
        QtMocHelpers::SlotData<void(QAction *, const QString &, const QString &)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 100, 101 }, { QMetaType::QString, 102 }, { QMetaType::QString, 103 },
        }}),
        // Slot 'removeAction'
        QtMocHelpers::SlotData<void(QAction *, const QString &)>(104, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 100, 101 }, { QMetaType::QString, 102 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<void(const QString &, QTextCodec *, bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 106 }, { 0x80000000 | 107, 108 }, { QMetaType::Bool, 109 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<void(const QString &, QTextCodec *)>(105, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 106 }, { 0x80000000 | 107, 108 },
        }}),
        // Slot 'reload'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setText'
        QtMocHelpers::SlotData<void(const QString &, bool)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::Bool, 112 },
        }}),
        // Slot 'setText'
        QtMocHelpers::SlotData<void(const QString &)>(111, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'setDocument'
        QtMocHelpers::SlotData<void(QDocument *)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 114, 115 },
        }}),
        // Slot 'addInputBinding'
        QtMocHelpers::SlotData<void(QEditorInputBindingInterface *)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 117, 118 },
        }}),
        // Slot 'removeInputBinding'
        QtMocHelpers::SlotData<void(QEditorInputBindingInterface *)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 117, 118 },
        }}),
        // Slot 'setInputBinding'
        QtMocHelpers::SlotData<void(QEditorInputBindingInterface *)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 117, 118 },
        }}),
        // Slot 'setCursor'
        QtMocHelpers::SlotData<void(const QDocumentCursor &, bool)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 122, 123 }, { QMetaType::Bool, 124 },
        }}),
        // Slot 'setCursor'
        QtMocHelpers::SlotData<void(const QDocumentCursor &)>(121, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 122, 123 },
        }}),
        // Slot 'setLanguageDefinition'
        QtMocHelpers::SlotData<void(QLanguageDefinition *)>(125, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 126, 115 },
        }}),
        // Slot 'setCompletionEngine'
        QtMocHelpers::SlotData<void(QCodeCompletionEngine *)>(127, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 128, 4 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void()>(129, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetZoom'
        QtMocHelpers::SlotData<void()>(131, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'zoom'
        QtMocHelpers::SlotData<void(int)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 133 },
        }}),
        // Slot 'setPanelMargins'
        QtMocHelpers::SlotData<void(qreal, qreal, qreal, qreal)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 22 }, { QMetaType::QReal, 135 }, { QMetaType::QReal, 136 }, { QMetaType::QReal, 118 },
        }}),
        // Slot 'getPanelMargins'
        QtMocHelpers::SlotData<void(qreal *, qreal *, qreal *, qreal *) const>(137, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 138, 22 }, { 0x80000000 | 138, 135 }, { 0x80000000 | 138, 136 }, { 0x80000000 | 138, 118 },
        }}),
        // Slot 'setTitle'
        QtMocHelpers::SlotData<void(const QString &)>(139, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'highlight'
        QtMocHelpers::SlotData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearPlaceHolders'
        QtMocHelpers::SlotData<void()>(140, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addPlaceHolder'
        QtMocHelpers::SlotData<void(const PlaceHolder &, bool)>(141, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 142, 143 }, { QMetaType::Bool, 144 },
        }}),
        // Slot 'addPlaceHolder'
        QtMocHelpers::SlotData<void(const PlaceHolder &)>(141, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 142, 143 },
        }}),
        // Slot 'addPlaceHolderMirror'
        QtMocHelpers::SlotData<void(int, const QDocumentCursor &)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 146 }, { 0x80000000 | 122, 123 },
        }}),
        // Slot 'removePlaceHolder'
        QtMocHelpers::SlotData<void(int)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 148 },
        }}),
        // Slot 'replacePlaceHolders'
        QtMocHelpers::SlotData<void(const QList<PlaceHolder> &)>(149, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 150, 151 },
        }}),
        // Slot 'placeHolderCount'
        QtMocHelpers::SlotData<int() const>(152, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'currentPlaceHolder'
        QtMocHelpers::SlotData<int() const>(153, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getPlaceHolder'
        QtMocHelpers::SlotData<void(int) const>(154, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 155 },
        }}),
        // Slot 'getPlaceHolders'
        QtMocHelpers::SlotData<QList<PlaceHolder>()>(156, 2, QMC::AccessPublic, 0x80000000 | 150),
        // Slot 'isAutoOverrideText'
        QtMocHelpers::SlotData<bool(const QString &) const>(157, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'resizeAutoOverridenPlaceholder'
        QtMocHelpers::SlotData<void(const QDocumentCursor &, int)>(158, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 122, 159 }, { QMetaType::Int, 160 },
        }}),
        // Slot 'nextPlaceHolder'
        QtMocHelpers::SlotData<bool()>(161, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'previousPlaceHolder'
        QtMocHelpers::SlotData<bool()>(162, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setPlaceHolder'
        QtMocHelpers::SlotData<void(int, bool)>(163, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 155 }, { QMetaType::Bool, 164 },
        }}),
        // Slot 'setPlaceHolder'
        QtMocHelpers::SlotData<void(int)>(163, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 155 },
        }}),
        // Slot 'setFileName'
        QtMocHelpers::SlotData<void(const QString &)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Slot 'checkClipboard'
        QtMocHelpers::SlotData<void()>(166, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reconnectWatcher'
        QtMocHelpers::SlotData<void()>(167, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'disconnectWatcher'
        QtMocHelpers::SlotData<void()>(168, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'fileChanged'
        QtMocHelpers::SlotData<void(const QString &)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Slot 'setContentClean'
        QtMocHelpers::SlotData<void(bool)>(170, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Slot 'emitCursorPositionChanged'
        QtMocHelpers::SlotData<void()>(171, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ensureCursorVisible'
        QtMocHelpers::SlotData<void(const QDocumentCursor &, MoveFlags)>(172, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 122, 173 }, { 0x80000000 | 174, 175 },
        }}),
        // Slot 'ensureCursorVisible'
        QtMocHelpers::SlotData<void(const QDocumentCursor &)>(172, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 122, 173 },
        }}),
        // Slot 'ensureCursorVisible'
        QtMocHelpers::SlotData<void(MoveFlags)>(172, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 174, 175 },
        }}),
        // Slot 'ensureCursorVisible'
        QtMocHelpers::SlotData<void()>(172, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setContentModified'
        QtMocHelpers::SlotData<void(bool)>(176, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Slot 'emitNeedUpdatedCompleter'
        QtMocHelpers::SlotData<void()>(177, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'pageUp'
        QtMocHelpers::SlotData<void(QDocumentCursor::MoveMode)>(178, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 179, 180 },
        }}),
        // Slot 'pageDown'
        QtMocHelpers::SlotData<void(QDocumentCursor::MoveMode)>(181, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 179, 180 },
        }}),
        // Slot 'repaintCursor'
        QtMocHelpers::SlotData<void()>(182, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ensureVisible'
        QtMocHelpers::SlotData<void(int)>(183, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 184 },
        }}),
        // Slot 'ensureVisible'
        QtMocHelpers::SlotData<void(const QRectF &)>(183, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 185, 186 },
        }}),
        // Slot 'insertText'
        QtMocHelpers::SlotData<void(QDocumentCursor &, const QString &)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 188, 123 }, { QMetaType::QString, 67 },
        }}),
        // Slot 'insertText'
        QtMocHelpers::SlotData<void(const QString &)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 67 },
        }}),
        // Slot 'documentWidthChanged'
        QtMocHelpers::SlotData<void(int)>(189, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 190 },
        }}),
        // Slot 'documentHeightChanged'
        QtMocHelpers::SlotData<void(int)>(191, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 190 },
        }}),
        // Slot 'repaintContent'
        QtMocHelpers::SlotData<void(int, int)>(192, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 155 }, { QMetaType::Int, 133 },
        }}),
        // Slot 'updateContent'
        QtMocHelpers::SlotData<void(int, int)>(193, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 155 }, { QMetaType::Int, 133 },
        }}),
        // Slot 'markChanged'
        QtMocHelpers::SlotData<void(QDocumentLineHandle *, int, bool)>(19, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 21, 22 }, { QMetaType::Int, 23 }, { QMetaType::Bool, 24 },
        }}),
        // Slot 'bindingSelected'
        QtMocHelpers::SlotData<void(QAction *)>(194, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 100, 101 },
        }}),
        // Slot 'lineEndingSelected'
        QtMocHelpers::SlotData<void(QAction *)>(195, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 100, 101 },
        }}),
        // Slot 'lineEndingChanged'
        QtMocHelpers::SlotData<void(int)>(196, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 197 },
        }}),
        // Method 'canUndo'
        QtMocHelpers::MethodData<bool() const>(198, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'canRedo'
        QtMocHelpers::MethodData<bool() const>(199, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'text'
        QtMocHelpers::MethodData<QString() const>(67, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'text'
        QtMocHelpers::MethodData<QString(int) const>(67, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 184 },
        }}),
        // Method 'document'
        QtMocHelpers::MethodData<QDocument *() const>(200, 2, QMC::AccessPublic, 0x80000000 | 114),
        // Method 'isCursorVisible'
        QtMocHelpers::MethodData<bool() const>(201, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'cursorMirrorCount'
        QtMocHelpers::MethodData<int() const>(202, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'cursorMirror'
        QtMocHelpers::MethodData<QDocumentCursor(int) const>(203, 2, QMC::AccessPublic, 0x80000000 | 122, {{
            { QMetaType::Int, 155 },
        }}),
        // Method 'cursors'
        QtMocHelpers::MethodData<QList<QDocumentCursor>() const>(204, 2, QMC::AccessPublic, 0x80000000 | 205),
        // Method 'scrollToFirstLine'
        QtMocHelpers::MethodData<void(int)>(206, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 22 },
        }}),
        // Method 'name'
        QtMocHelpers::MethodData<QString() const>(207, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'fileName'
        QtMocHelpers::MethodData<QString() const>(208, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'fileInfo'
        QtMocHelpers::MethodData<QFileInfo() const>(209, 2, QMC::AccessPublic, 0x80000000 | 210),
        // Method 'isReadOnly'
        QtMocHelpers::MethodData<bool() const>(211, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setReadOnly'
        QtMocHelpers::MethodData<void(bool)>(212, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 118 },
        }}),
        // Method 'isContentModified'
        QtMocHelpers::MethodData<bool() const>(213, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isInConflict'
        QtMocHelpers::MethodData<bool() const>(214, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'getFileCodec'
        QtMocHelpers::MethodData<QTextCodec *() const>(215, 2, QMC::AccessPublic, 0x80000000 | 107),
        // Method 'setFileCodec'
        QtMocHelpers::MethodData<void(QTextCodec *)>(216, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 107, 108 },
        }}),
        // Method 'clearCursorMirrors'
        QtMocHelpers::MethodData<void()>(217, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'addCursorMirror'
        QtMocHelpers::MethodData<void(const QDocumentCursor &)>(218, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 122, 123 },
        }}),
        // Method 'cursorMirrorsRemoveSelectedText'
        QtMocHelpers::MethodData<void()>(219, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'cursor'
        QtMocHelpers::PropertyData<QDocumentCursor>(173, 0x80000000 | 122, QMC::Readable | QMC::Writable | QMC::Scriptable | QMC::EnumOrFlag | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QEditor, qt_meta_tag_ZN7QEditorE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QEditor::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractScrollArea::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QEditorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7QEditorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7QEditorE_t>.metaTypes,
    nullptr
} };

void QEditor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QEditor *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loaded((*reinterpret_cast<std::add_pointer_t<QEditor*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 1: _t->saved((*reinterpret_cast<std::add_pointer_t<QEditor*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 2: _t->contentModified((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->readOnlyChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->titleChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->focusReceived(); break;
        case 6: _t->textEdited((*reinterpret_cast<std::add_pointer_t<QKeyEvent*>>(_a[1]))); break;
        case 7: _t->cursorPositionChanged(); break;
        case 8: _t->copyAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->undoAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->redoAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->markChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 12: _t->hovered((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 13: _t->fileReloaded(); break;
        case 14: _t->fileInConflict(); break;
        case 15: _t->fileInConflictShowDiff(); break;
        case 16: _t->fileAutoReloading((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 17: _t->needUpdatedCompleter(); break;
        case 18: _t->requestClose(); break;
        case 19: _t->cursorHovered(); break;
        case 20: _t->emitWordDoubleClicked(); break;
        case 21: _t->visibleLinesChanged(); break;
        case 22: _t->slowOperationStarted(); break;
        case 23: _t->slowOperationEnded(); break;
        case 24: _t->undo(); break;
        case 25: _t->redo(); break;
        case 26: _t->cut(); break;
        case 27: _t->copy(); break;
        case 28: _t->paste(); break;
        case 29: _t->selectAll(); break;
        case 30: _t->selectNothing(); break;
        case 31: _t->selectExpand((*reinterpret_cast<std::add_pointer_t<QDocumentCursor::SelectionType>>(_a[1]))); break;
        case 32: _t->selectExpandToNextWord(); break;
        case 33: _t->selectExpandToNextLine(); break;
        case 34: _t->selectAllOccurences(); break;
        case 35: _t->selectNextOccurence(); break;
        case 36: _t->selectPrevOccurence(); break;
        case 37: _t->selectNextOccurenceKeepMirror(); break;
        case 38: _t->selectPrevOccurenceKeepMirror(); break;
        case 39: _t->selectOccurence((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 40: _t->relayPanelCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[3]))); break;
        case 41: _t->relayPanelCommand((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 42: _t->find(); break;
        case 43: _t->find((*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])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5]))); break;
        case 44: _t->find((*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 45: _t->find((*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]))); break;
        case 46: _t->find((*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])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[7]))); break;
        case 47: _t->findInSameDir(); break;
        case 48: _t->findNext(); break;
        case 49: _t->findPrev(); break;
        case 50: _t->findCount(); break;
        case 51: _t->selectAllMatches(); break;
        case 52: _t->replacePanel(); break;
        case 53: _t->replaceNext(); break;
        case 54: _t->replacePrev(); break;
        case 55: _t->replaceAll(); break;
        case 56: _t->gotoLine(); break;
        case 57: _t->tabOrIndentSelection(); break;
        case 58: _t->insertTab(); break;
        case 59: _t->indentSelection(); break;
        case 60: _t->unindentSelection(); break;
        case 61: _t->commentSelection(); break;
        case 62: _t->uncommentSelection(); break;
        case 63: _t->toggleCommentSelection(); break;
        case 64: _t->setLineWrapping((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 65: _t->setHardLineWrapping((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 66: _t->setSoftLimitedLineWrapping((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 67: _t->setWrapAfterNumChars((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 68: _t->print(); break;
        case 69: _t->retranslate(); break;
        case 70: _t->write((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 71: _t->addAction((*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]))); break;
        case 72: _t->addAction((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 73: _t->removeAction((*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]))); break;
        case 74: _t->removeAction((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 75: _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QTextCodec*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 76: _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QTextCodec*>>(_a[2]))); break;
        case 77: _t->reload(); break;
        case 78: _t->setText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 79: _t->setText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 80: _t->setDocument((*reinterpret_cast<std::add_pointer_t<QDocument*>>(_a[1]))); break;
        case 81: _t->addInputBinding((*reinterpret_cast<std::add_pointer_t<QEditorInputBindingInterface*>>(_a[1]))); break;
        case 82: _t->removeInputBinding((*reinterpret_cast<std::add_pointer_t<QEditorInputBindingInterface*>>(_a[1]))); break;
        case 83: _t->setInputBinding((*reinterpret_cast<std::add_pointer_t<QEditorInputBindingInterface*>>(_a[1]))); break;
        case 84: _t->setCursor((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 85: _t->setCursor((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 86: _t->setLanguageDefinition((*reinterpret_cast<std::add_pointer_t<QLanguageDefinition*>>(_a[1]))); break;
        case 87: _t->setCompletionEngine((*reinterpret_cast<std::add_pointer_t<QCodeCompletionEngine*>>(_a[1]))); break;
        case 88: _t->zoomIn(); break;
        case 89: _t->zoomOut(); break;
        case 90: _t->resetZoom(); break;
        case 91: _t->zoom((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 92: _t->setPanelMargins((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[4]))); break;
        case 93: _t->getPanelMargins((*reinterpret_cast<std::add_pointer_t<qreal*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qreal*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<qreal*>>(_a[4]))); break;
        case 94: _t->setTitle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 95: _t->highlight(); break;
        case 96: _t->clearPlaceHolders(); break;
        case 97: _t->addPlaceHolder((*reinterpret_cast<std::add_pointer_t<PlaceHolder>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 98: _t->addPlaceHolder((*reinterpret_cast<std::add_pointer_t<PlaceHolder>>(_a[1]))); break;
        case 99: _t->addPlaceHolderMirror((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[2]))); break;
        case 100: _t->removePlaceHolder((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 101: _t->replacePlaceHolders((*reinterpret_cast<std::add_pointer_t<QList<PlaceHolder>>>(_a[1]))); break;
        case 102: { int _r = _t->placeHolderCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 103: { int _r = _t->currentPlaceHolder();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 104: _t->getPlaceHolder((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 105: { QList<PlaceHolder> _r = _t->getPlaceHolders();
            if (_a[0]) *reinterpret_cast<QList<PlaceHolder>*>(_a[0]) = std::move(_r); }  break;
        case 106: { bool _r = _t->isAutoOverrideText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 107: _t->resizeAutoOverridenPlaceholder((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 108: { bool _r = _t->nextPlaceHolder();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 109: { bool _r = _t->previousPlaceHolder();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 110: _t->setPlaceHolder((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 111: _t->setPlaceHolder((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 112: _t->setFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 113: _t->checkClipboard(); break;
        case 114: _t->reconnectWatcher(); break;
        case 115: _t->disconnectWatcher(); break;
        case 116: _t->fileChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 117: _t->setContentClean((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 118: _t->emitCursorPositionChanged(); break;
        case 119: _t->ensureCursorVisible((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MoveFlags>>(_a[2]))); break;
        case 120: _t->ensureCursorVisible((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 121: _t->ensureCursorVisible((*reinterpret_cast<std::add_pointer_t<MoveFlags>>(_a[1]))); break;
        case 122: _t->ensureCursorVisible(); break;
        case 123: _t->setContentModified((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 124: _t->emitNeedUpdatedCompleter(); break;
        case 125: _t->pageUp((*reinterpret_cast<std::add_pointer_t<QDocumentCursor::MoveMode>>(_a[1]))); break;
        case 126: _t->pageDown((*reinterpret_cast<std::add_pointer_t<QDocumentCursor::MoveMode>>(_a[1]))); break;
        case 127: _t->repaintCursor(); break;
        case 128: _t->ensureVisible((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 129: _t->ensureVisible((*reinterpret_cast<std::add_pointer_t<QRectF>>(_a[1]))); break;
        case 130: _t->insertText((*reinterpret_cast<std::add_pointer_t<QDocumentCursor&>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 131: _t->insertText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 132: _t->documentWidthChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 133: _t->documentHeightChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 134: _t->repaintContent((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 135: _t->updateContent((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 136: _t->markChanged((*reinterpret_cast<std::add_pointer_t<QDocumentLineHandle*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 137: _t->bindingSelected((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 138: _t->lineEndingSelected((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 139: _t->lineEndingChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 140: { bool _r = _t->canUndo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 141: { bool _r = _t->canRedo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 142: { QString _r = _t->text();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 143: { QString _r = _t->text((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 144: { QDocument* _r = _t->document();
            if (_a[0]) *reinterpret_cast<QDocument**>(_a[0]) = std::move(_r); }  break;
        case 145: { bool _r = _t->isCursorVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 146: { int _r = _t->cursorMirrorCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 147: { QDocumentCursor _r = _t->cursorMirror((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDocumentCursor*>(_a[0]) = std::move(_r); }  break;
        case 148: { QList<QDocumentCursor> _r = _t->cursors();
            if (_a[0]) *reinterpret_cast<QList<QDocumentCursor>*>(_a[0]) = std::move(_r); }  break;
        case 149: _t->scrollToFirstLine((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 150: { QString _r = _t->name();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 151: { QString _r = _t->fileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 152: { QFileInfo _r = _t->fileInfo();
            if (_a[0]) *reinterpret_cast<QFileInfo*>(_a[0]) = std::move(_r); }  break;
        case 153: { bool _r = _t->isReadOnly();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 154: _t->setReadOnly((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 155: { bool _r = _t->isContentModified();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 156: { bool _r = _t->isInConflict();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 157: { QTextCodec* _r = _t->getFileCodec();
            if (_a[0]) *reinterpret_cast<QTextCodec**>(_a[0]) = std::move(_r); }  break;
        case 158: _t->setFileCodec((*reinterpret_cast<std::add_pointer_t<QTextCodec*>>(_a[1]))); break;
        case 159: _t->clearCursorMirrors(); break;
        case 160: _t->addCursorMirror((*reinterpret_cast<std::add_pointer_t<QDocumentCursor>>(_a[1]))); break;
        case 161: _t->cursorMirrorsRemoveSelectedText(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QEditor* >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QEditor* >(); break;
            }
            break;
        case 71:
            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 72:
            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 73:
            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 74:
            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 80:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocument* >(); break;
            }
            break;
        case 84:
            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 85:
            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 99:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDocumentCursor >(); break;
            }
            break;
        case 107:
            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 119:
            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 120:
            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 137:
            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 138:
            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 160:
            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;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(QEditor * , const QString & )>(_a, &QEditor::loaded, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(QEditor * , const QString & )>(_a, &QEditor::saved, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(bool )>(_a, &QEditor::contentModified, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(bool )>(_a, &QEditor::readOnlyChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(const QString & )>(_a, &QEditor::titleChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::focusReceived, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(QKeyEvent * )>(_a, &QEditor::textEdited, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::cursorPositionChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(bool )>(_a, &QEditor::copyAvailable, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(bool )>(_a, &QEditor::undoAvailable, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(bool )>(_a, &QEditor::redoAvailable, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(const QString & , QDocumentLineHandle * , int , bool )>(_a, &QEditor::markChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(QPoint )>(_a, &QEditor::hovered, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::fileReloaded, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::fileInConflict, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::fileInConflictShowDiff, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)(QString )>(_a, &QEditor::fileAutoReloading, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::needUpdatedCompleter, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::requestClose, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::cursorHovered, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::emitWordDoubleClicked, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::visibleLinesChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::slowOperationStarted, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (QEditor::*)()>(_a, &QEditor::slowOperationEnded, 23))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDocumentCursor >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDocumentCursor*>(_v) = _t->cursor(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setCursor(*reinterpret_cast<QDocumentCursor*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QEditor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractScrollArea::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 162)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 162;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 162)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 162;
    }
    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 QEditor::loaded(QEditor * _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void QEditor::saved(QEditor * _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void QEditor::contentModified(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void QEditor::readOnlyChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

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

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

// SIGNAL 6
void QEditor::textEdited(QKeyEvent * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void QEditor::cursorPositionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void QEditor::copyAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void QEditor::undoAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void QEditor::redoAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void QEditor::markChanged(const QString & _t1, QDocumentLineHandle * _t2, int _t3, bool _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 12
void QEditor::hovered(QPoint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void QEditor::fileReloaded()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void QEditor::fileInConflict()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void QEditor::fileInConflictShowDiff()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void QEditor::fileAutoReloading(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void QEditor::needUpdatedCompleter()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void QEditor::requestClose()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void QEditor::cursorHovered()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void QEditor::emitWordDoubleClicked()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void QEditor::visibleLinesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void QEditor::slowOperationStarted()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void QEditor::slowOperationEnded()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}
QT_WARNING_POP
