/****************************************************************************
** Meta object code from reading C++ file 'editors.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/editors.h"
#include <QtGui/qtextcursor.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 'editors.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_ZN7EditorsE_t {};
} // unnamed namespace

template <> constexpr inline auto Editors::qt_create_metaobjectdata<qt_meta_tag_ZN7EditorsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Editors",
        "currentEditorChanged",
        "",
        "visibleEditorsChanged",
        "editorAboutToChangeByTabClick",
        "LatexEditorView*",
        "from",
        "to",
        "closeCurrentEditorRequested",
        "listOfEditorsChanged",
        "editorsReordered",
        "requestCloseEditor",
        "edView",
        "removeEditor",
        "setCurrentEditorFromAction",
        "setCurrentEditorFromSender",
        "closeEditorFromAction",
        "closeOtherEditorsFromAction",
        "toggleReadOnlyFromAction",
        "activateNextEditor",
        "activatePreviousEditor",
        "changeSplitOrientation",
        "setCurrentGroup",
        "index",
        "activateTabWidgetFromSender",
        "tabBarContextMenu",
        "QPoint",
        "point",
        "onEditorChangeByTabClick",
        "moveToOtherTabGroup",
        "moveAllToOtherTabGroup",
        "moveAllOthersToOtherTabGroup",
        "moveToTabGroup",
        "TxsTabWidget*",
        "target",
        "targetIndex",
        "showInGraphicalShell_",
        "copyFilePath"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'currentEditorChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'visibleEditorsChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'editorAboutToChangeByTabClick'
        QtMocHelpers::SignalData<void(LatexEditorView *, LatexEditorView *)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 5, 7 },
        }}),
        // Signal 'closeCurrentEditorRequested'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'listOfEditorsChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'editorsReordered'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestCloseEditor'
        QtMocHelpers::SlotData<void(LatexEditorView *)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 12 },
        }}),
        // Slot 'removeEditor'
        QtMocHelpers::SlotData<void(LatexEditorView *)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 12 },
        }}),
        // Slot 'setCurrentEditorFromAction'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setCurrentEditorFromSender'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'closeEditorFromAction'
        QtMocHelpers::SlotData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'closeOtherEditorsFromAction'
        QtMocHelpers::SlotData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleReadOnlyFromAction'
        QtMocHelpers::SlotData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'activateNextEditor'
        QtMocHelpers::SlotData<bool()>(19, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'activatePreviousEditor'
        QtMocHelpers::SlotData<bool()>(20, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'changeSplitOrientation'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setCurrentGroup'
        QtMocHelpers::SlotData<void(int)>(22, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 23 },
        }}),
        // Slot 'activateTabWidgetFromSender'
        QtMocHelpers::SlotData<bool()>(24, 2, QMC::AccessProtected, QMetaType::Bool),
        // Slot 'tabBarContextMenu'
        QtMocHelpers::SlotData<void(const QPoint &)>(25, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Slot 'onEditorChangeByTabClick'
        QtMocHelpers::SlotData<void(LatexEditorView *, LatexEditorView *)>(28, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { 0x80000000 | 5, 7 },
        }}),
        // Slot 'moveToOtherTabGroup'
        QtMocHelpers::SlotData<void()>(29, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'moveAllToOtherTabGroup'
        QtMocHelpers::SlotData<void()>(30, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'moveAllOthersToOtherTabGroup'
        QtMocHelpers::SlotData<void()>(31, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'moveToTabGroup'
        QtMocHelpers::SlotData<void(LatexEditorView *, TxsTabWidget *, int)>(32, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 5, 12 }, { 0x80000000 | 33, 34 }, { QMetaType::Int, 35 },
        }}),
        // Slot 'showInGraphicalShell_'
        QtMocHelpers::SlotData<void()>(36, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'copyFilePath'
        QtMocHelpers::SlotData<void()>(37, 2, QMC::AccessProtected, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Editors, qt_meta_tag_ZN7EditorsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Editors::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7EditorsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7EditorsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7EditorsE_t>.metaTypes,
    nullptr
} };

void Editors::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Editors *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->currentEditorChanged(); break;
        case 1: _t->visibleEditorsChanged(); break;
        case 2: _t->editorAboutToChangeByTabClick((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[2]))); break;
        case 3: _t->closeCurrentEditorRequested(); break;
        case 4: _t->listOfEditorsChanged(); break;
        case 5: _t->editorsReordered(); break;
        case 6: _t->requestCloseEditor((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1]))); break;
        case 7: _t->removeEditor((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1]))); break;
        case 8: _t->setCurrentEditorFromAction(); break;
        case 9: _t->setCurrentEditorFromSender(); break;
        case 10: _t->closeEditorFromAction(); break;
        case 11: _t->closeOtherEditorsFromAction(); break;
        case 12: _t->toggleReadOnlyFromAction(); break;
        case 13: { bool _r = _t->activateNextEditor();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 14: { bool _r = _t->activatePreviousEditor();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 15: _t->changeSplitOrientation(); break;
        case 16: _t->setCurrentGroup((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 17: { bool _r = _t->activateTabWidgetFromSender();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 18: _t->tabBarContextMenu((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 19: _t->onEditorChangeByTabClick((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[2]))); break;
        case 20: _t->moveToOtherTabGroup(); break;
        case 21: _t->moveAllToOtherTabGroup(); break;
        case 22: _t->moveAllOthersToOtherTabGroup(); break;
        case 23: _t->moveToTabGroup((*reinterpret_cast<std::add_pointer_t<LatexEditorView*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<TxsTabWidget*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 24: _t->showInGraphicalShell_(); break;
        case 25: _t->copyFilePath(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Editors::*)()>(_a, &Editors::currentEditorChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Editors::*)()>(_a, &Editors::visibleEditorsChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Editors::*)(LatexEditorView * , LatexEditorView * )>(_a, &Editors::editorAboutToChangeByTabClick, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Editors::*)()>(_a, &Editors::closeCurrentEditorRequested, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Editors::*)()>(_a, &Editors::listOfEditorsChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Editors::*)()>(_a, &Editors::editorsReordered, 5))
            return;
    }
}

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

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

int Editors::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 26)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 26;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 26)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 26;
    }
    return _id;
}

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

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

// SIGNAL 2
void Editors::editorAboutToChangeByTabClick(LatexEditorView * _t1, LatexEditorView * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

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

// SIGNAL 4
void Editors::listOfEditorsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void Editors::editorsReordered()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}
namespace {
struct qt_meta_tag_ZN17EditorChangeProxyE_t {};
} // unnamed namespace

template <> constexpr inline auto EditorChangeProxy::qt_create_metaobjectdata<qt_meta_tag_ZN17EditorChangeProxyE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "EditorChangeProxy",
        "currentEditorChanged",
        "",
        "listOfEditorsChanged",
        "currentEditorChange",
        "listOfEditorsChange"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'currentEditorChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'listOfEditorsChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'currentEditorChange'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'listOfEditorsChange'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<EditorChangeProxy, qt_meta_tag_ZN17EditorChangeProxyE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject EditorChangeProxy::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17EditorChangeProxyE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17EditorChangeProxyE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17EditorChangeProxyE_t>.metaTypes,
    nullptr
} };

void EditorChangeProxy::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<EditorChangeProxy *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->currentEditorChanged(); break;
        case 1: _t->listOfEditorsChanged(); break;
        case 2: _t->currentEditorChange(); break;
        case 3: _t->listOfEditorsChange(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (EditorChangeProxy::*)()>(_a, &EditorChangeProxy::currentEditorChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (EditorChangeProxy::*)()>(_a, &EditorChangeProxy::listOfEditorsChanged, 1))
            return;
    }
}

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

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

int EditorChangeProxy::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 4;
    }
    return _id;
}

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

// SIGNAL 1
void EditorChangeProxy::listOfEditorsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
QT_WARNING_POP
