/****************************************************************************
** Meta object code from reading C++ file 'worksheet.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 "../../../../cantor-26.04.3/src/worksheet.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 'worksheet.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_ZN9WorksheetE_t {};
} // unnamed namespace

template <> constexpr inline auto Worksheet::qt_create_metaobjectdata<qt_meta_tag_ZN9WorksheetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Worksheet",
        "modified",
        "",
        "loaded",
        "showHelp",
        "hierarchyChanged",
        "QList<int>",
        "hierarhyEntryNameChange",
        "name",
        "searchName",
        "depth",
        "updatePrompt",
        "undoAvailable",
        "redoAvailable",
        "undo",
        "redo",
        "cutAvailable",
        "copyAvailable",
        "pasteAvailable",
        "cut",
        "copy",
        "requestDocumentation",
        "appendCommandEntry",
        "WorksheetEntry*",
        "appendTextEntry",
        "appendMarkdownEntry",
        "appendImageEntry",
        "appendPageBreakEntry",
        "appendLatexEntry",
        "appendHorizontalRuleEntry",
        "appendHierarchyEntry",
        "insertCommandEntry",
        "current",
        "insertTextEntry",
        "insertMarkdownEntry",
        "insertImageEntry",
        "insertPageBreakEntry",
        "insertLatexEntry",
        "insertHorizontalRuleEntry",
        "insertHierarchyEntry",
        "insertCommandEntryBefore",
        "insertTextEntryBefore",
        "insertMarkdownEntryBefore",
        "insertImageEntryBefore",
        "insertPageBreakEntryBefore",
        "insertLatexEntryBefore",
        "insertHorizontalRuleEntryBefore",
        "insertHierarchyEntryBefore",
        "updateLayout",
        "updateHierarchyLayout",
        "updateHierarchyControlsLayout",
        "startEntry",
        "updateEntrySize",
        "print",
        "QPrinter*",
        "paste",
        "focusEntry",
        "evaluate",
        "evaluateCurrentEntry",
        "interrupt",
        "interruptCurrentEntryEvaluation",
        "completionEnabled",
        "showCompletion",
        "initActions",
        "setVariableHighlightingEnabled",
        "enabled",
        "enableCompletion",
        "enableExpressionNumbering",
        "enableAnimations",
        "enableEmbeddedMath",
        "toXML",
        "QDomDocument",
        "KZip*",
        "archive",
        "save",
        "QIODevice*",
        "saveToByteArray",
        "savePlain",
        "saveLatex",
        "load",
        "QByteArray*",
        "gotResult",
        "Cantor::Expression*",
        "expr",
        "removeCurrentEntry",
        "setFirstEntry",
        "setLastEntry",
        "invalidateFirstEntry",
        "invalidateLastEntry",
        "updateFocusedTextItem",
        "WorksheetTextEditorItem*",
        "WorksheetTextItem*",
        "updateDragScrollTimer",
        "registerShortcut",
        "QAction*",
        "updateShortcut",
        "setRichTextInformation",
        "Worksheet::RichTextInfo",
        "setAcceptRichText",
        "b",
        "setTextForegroundColor",
        "setTextBackgroundColor",
        "setTextBold",
        "setTextItalic",
        "setTextUnderline",
        "setTextStrikeOut",
        "setAlignLeft",
        "setAlignRight",
        "setAlignCenter",
        "setAlignJustify",
        "setFontFamily",
        "setFontSize",
        "size",
        "changeEntryType",
        "target",
        "newType",
        "collapseSelectionResults",
        "collapseAllResults",
        "uncollapseSelectionResults",
        "uncollapseAllResults",
        "removeSelectionResults",
        "removeAllResults",
        "addToExectuionSelection",
        "excludeFromExecutionSelection",
        "requestScrollToHierarchyEntry",
        "clearAllSelections",
        "handleSettingsChanges",
        "appendEntry",
        "type",
        "focus",
        "insertEntry",
        "insertEntryBefore",
        "selectionRemove",
        "selectionEvaluate",
        "selectionMoveUp",
        "selectionMoveDown",
        "animateEntryCursor"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'modified'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'loaded'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showHelp'
        QtMocHelpers::SignalData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'hierarchyChanged'
        QtMocHelpers::SignalData<void(const QStringList &, const QStringList &, const QList<int> &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 2 }, { QMetaType::QStringList, 2 }, { 0x80000000 | 6, 2 },
        }}),
        // Signal 'hierarhyEntryNameChange'
        QtMocHelpers::SignalData<void(QString, QString, int)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 9 }, { QMetaType::Int, 10 },
        }}),
        // Signal 'updatePrompt'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'undoAvailable'
        QtMocHelpers::SignalData<void(bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'redoAvailable'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'undo'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'redo'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cutAvailable'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'copyAvailable'
        QtMocHelpers::SignalData<void(bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'pasteAvailable'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'cut'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'copy'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'requestDocumentation'
        QtMocHelpers::SignalData<void(const QString &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'appendCommandEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(22, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendCommandEntry'
        QtMocHelpers::SlotData<void(const QString &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'appendTextEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(24, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendMarkdownEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(25, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendImageEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(26, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendPageBreakEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(27, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendLatexEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(28, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendHorizontalRuleEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(29, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'appendHierarchyEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(30, 2, QMC::AccessPublic, 0x80000000 | 23),
        // Slot 'insertCommandEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(31, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertCommandEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(31, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertTextEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(33, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertTextEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(33, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertMarkdownEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(34, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertMarkdownEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(34, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertImageEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(35, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertImageEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(35, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertPageBreakEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(36, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertPageBreakEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(36, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertLatexEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(37, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertLatexEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(37, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertHorizontalRuleEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(38, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertHorizontalRuleEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(38, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertHierarchyEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(39, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertHierarchyEntry'
        QtMocHelpers::SlotData<WorksheetEntry *()>(39, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertCommandEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(40, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertCommandEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(40, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertTextEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(41, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertTextEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(41, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertMarkdownEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(42, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertMarkdownEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(42, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertImageEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(43, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertImageEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(43, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertPageBreakEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(44, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertPageBreakEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(44, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertLatexEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(45, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertLatexEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(45, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertHorizontalRuleEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(46, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertHorizontalRuleEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(46, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'insertHierarchyEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(WorksheetEntry *)>(47, 2, QMC::AccessPublic, 0x80000000 | 23, {{
            { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertHierarchyEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *()>(47, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 23),
        // Slot 'updateLayout'
        QtMocHelpers::SlotData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateHierarchyLayout'
        QtMocHelpers::SlotData<void()>(49, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateHierarchyControlsLayout'
        QtMocHelpers::SlotData<void(WorksheetEntry *)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 51 },
        }}),
        // Slot 'updateHierarchyControlsLayout'
        QtMocHelpers::SlotData<void()>(50, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'updateEntrySize'
        QtMocHelpers::SlotData<void(WorksheetEntry *)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Slot 'print'
        QtMocHelpers::SlotData<void(QPrinter *)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 54, 2 },
        }}),
        // Slot 'paste'
        QtMocHelpers::SlotData<void()>(55, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'focusEntry'
        QtMocHelpers::SlotData<void(WorksheetEntry *)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Slot 'evaluate'
        QtMocHelpers::SlotData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'evaluateCurrentEntry'
        QtMocHelpers::SlotData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'interrupt'
        QtMocHelpers::SlotData<void()>(59, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'interruptCurrentEntryEvaluation'
        QtMocHelpers::SlotData<void()>(60, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'completionEnabled'
        QtMocHelpers::SlotData<bool()>(61, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'showCompletion'
        QtMocHelpers::SlotData<void()>(62, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'initActions'
        QtMocHelpers::SlotData<void()>(63, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setVariableHighlightingEnabled'
        QtMocHelpers::SlotData<void(bool)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 65 },
        }}),
        // Slot 'enableCompletion'
        QtMocHelpers::SlotData<void(bool)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'enableExpressionNumbering'
        QtMocHelpers::SlotData<void(bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'enableAnimations'
        QtMocHelpers::SlotData<void(bool)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'enableEmbeddedMath'
        QtMocHelpers::SlotData<void(bool)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'toXML'
        QtMocHelpers::SlotData<QDomDocument(KZip *)>(70, 2, QMC::AccessPublic, 0x80000000 | 71, {{
            { 0x80000000 | 72, 73 },
        }}),
        // Slot 'toXML'
        QtMocHelpers::SlotData<QDomDocument()>(70, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 71),
        // Slot 'save'
        QtMocHelpers::SlotData<void(const QString &)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'save'
        QtMocHelpers::SlotData<void(QIODevice *)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 2 },
        }}),
        // Slot 'saveToByteArray'
        QtMocHelpers::SlotData<QByteArray()>(76, 2, QMC::AccessPublic, QMetaType::QByteArray),
        // Slot 'savePlain'
        QtMocHelpers::SlotData<void(const QString &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'saveLatex'
        QtMocHelpers::SlotData<void(const QString &)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<bool(QIODevice *)>(79, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 75, 2 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<void(QByteArray *)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 80, 2 },
        }}),
        // Slot 'load'
        QtMocHelpers::SlotData<bool(const QString &)>(79, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'gotResult'
        QtMocHelpers::SlotData<void(Cantor::Expression *)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 82, 83 },
        }}),
        // Slot 'gotResult'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'removeCurrentEntry'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFirstEntry'
        QtMocHelpers::SlotData<void(WorksheetEntry *)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Slot 'setLastEntry'
        QtMocHelpers::SlotData<void(WorksheetEntry *)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 2 },
        }}),
        // Slot 'invalidateFirstEntry'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'invalidateLastEntry'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateFocusedTextItem'
        QtMocHelpers::SlotData<void(WorksheetTextEditorItem *)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 90, 2 },
        }}),
        // Slot 'updateFocusedTextItem'
        QtMocHelpers::SlotData<void(WorksheetTextItem *)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 91, 2 },
        }}),
        // Slot 'updateDragScrollTimer'
        QtMocHelpers::SlotData<void()>(92, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'registerShortcut'
        QtMocHelpers::SlotData<void(QAction *)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 94, 2 },
        }}),
        // Slot 'updateShortcut'
        QtMocHelpers::SlotData<void()>(95, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setRichTextInformation'
        QtMocHelpers::SlotData<void(const Worksheet::RichTextInfo &)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 97, 2 },
        }}),
        // Slot 'setAcceptRichText'
        QtMocHelpers::SlotData<void(bool)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 99 },
        }}),
        // Slot 'setTextForegroundColor'
        QtMocHelpers::SlotData<void()>(100, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setTextBackgroundColor'
        QtMocHelpers::SlotData<void()>(101, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setTextBold'
        QtMocHelpers::SlotData<void(bool)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 99 },
        }}),
        // Slot 'setTextItalic'
        QtMocHelpers::SlotData<void(bool)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 99 },
        }}),
        // Slot 'setTextUnderline'
        QtMocHelpers::SlotData<void(bool)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 99 },
        }}),
        // Slot 'setTextStrikeOut'
        QtMocHelpers::SlotData<void(bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 99 },
        }}),
        // Slot 'setAlignLeft'
        QtMocHelpers::SlotData<void()>(106, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setAlignRight'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setAlignCenter'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setAlignJustify'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFontFamily'
        QtMocHelpers::SlotData<void(const QString &)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'setFontSize'
        QtMocHelpers::SlotData<void(int)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 112 },
        }}),
        // Slot 'changeEntryType'
        QtMocHelpers::SlotData<void(WorksheetEntry *, int)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 114 }, { QMetaType::Int, 115 },
        }}),
        // Slot 'collapseSelectionResults'
        QtMocHelpers::SlotData<void()>(116, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'collapseAllResults'
        QtMocHelpers::SlotData<void()>(117, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'uncollapseSelectionResults'
        QtMocHelpers::SlotData<void()>(118, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'uncollapseAllResults'
        QtMocHelpers::SlotData<void()>(119, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'removeSelectionResults'
        QtMocHelpers::SlotData<void()>(120, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'removeAllResults'
        QtMocHelpers::SlotData<void()>(121, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addToExectuionSelection'
        QtMocHelpers::SlotData<void()>(122, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'excludeFromExecutionSelection'
        QtMocHelpers::SlotData<void()>(123, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestScrollToHierarchyEntry'
        QtMocHelpers::SlotData<void(QString)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'clearAllSelections'
        QtMocHelpers::SlotData<void()>(125, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'handleSettingsChanges'
        QtMocHelpers::SlotData<void()>(126, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'appendEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(int, bool)>(127, 2, QMC::AccessPrivate, 0x80000000 | 23, {{
            { QMetaType::Int, 128 }, { QMetaType::Bool, 129 },
        }}),
        // Slot 'appendEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(int)>(127, 2, QMC::AccessPrivate | QMC::MethodCloned, 0x80000000 | 23, {{
            { QMetaType::Int, 128 },
        }}),
        // Slot 'insertEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(int, WorksheetEntry *)>(130, 2, QMC::AccessPrivate, 0x80000000 | 23, {{
            { QMetaType::Int, 128 }, { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertEntry'
        QtMocHelpers::SlotData<WorksheetEntry *(int)>(130, 2, QMC::AccessPrivate | QMC::MethodCloned, 0x80000000 | 23, {{
            { QMetaType::Int, 128 },
        }}),
        // Slot 'insertEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(int, WorksheetEntry *)>(131, 2, QMC::AccessPrivate, 0x80000000 | 23, {{
            { QMetaType::Int, 128 }, { 0x80000000 | 23, 32 },
        }}),
        // Slot 'insertEntryBefore'
        QtMocHelpers::SlotData<WorksheetEntry *(int)>(131, 2, QMC::AccessPrivate | QMC::MethodCloned, 0x80000000 | 23, {{
            { QMetaType::Int, 128 },
        }}),
        // Slot 'selectionRemove'
        QtMocHelpers::SlotData<void()>(132, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectionEvaluate'
        QtMocHelpers::SlotData<void()>(133, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectionMoveUp'
        QtMocHelpers::SlotData<void()>(134, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'selectionMoveDown'
        QtMocHelpers::SlotData<void()>(135, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'animateEntryCursor'
        QtMocHelpers::SlotData<void()>(136, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Worksheet, qt_meta_tag_ZN9WorksheetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Worksheet::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsScene::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9WorksheetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9WorksheetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9WorksheetE_t>.metaTypes,
    nullptr
} };

void Worksheet::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Worksheet *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->modified(); break;
        case 1: _t->loaded(); break;
        case 2: _t->showHelp((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->hierarchyChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<int>>>(_a[3]))); break;
        case 4: _t->hierarhyEntryNameChange((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 5: _t->updatePrompt(); break;
        case 6: _t->undoAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->redoAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->undo(); break;
        case 9: _t->redo(); break;
        case 10: _t->cutAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->copyAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->pasteAvailable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->cut(); break;
        case 14: _t->copy(); break;
        case 15: _t->requestDocumentation((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 16: { WorksheetEntry* _r = _t->appendCommandEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 17: _t->appendCommandEntry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: { WorksheetEntry* _r = _t->appendTextEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 19: { WorksheetEntry* _r = _t->appendMarkdownEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 20: { WorksheetEntry* _r = _t->appendImageEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 21: { WorksheetEntry* _r = _t->appendPageBreakEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 22: { WorksheetEntry* _r = _t->appendLatexEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 23: { WorksheetEntry* _r = _t->appendHorizontalRuleEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 24: { WorksheetEntry* _r = _t->appendHierarchyEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 25: { WorksheetEntry* _r = _t->insertCommandEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 26: { WorksheetEntry* _r = _t->insertCommandEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 27: { WorksheetEntry* _r = _t->insertTextEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 28: { WorksheetEntry* _r = _t->insertTextEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 29: { WorksheetEntry* _r = _t->insertMarkdownEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 30: { WorksheetEntry* _r = _t->insertMarkdownEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 31: { WorksheetEntry* _r = _t->insertImageEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 32: { WorksheetEntry* _r = _t->insertImageEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 33: { WorksheetEntry* _r = _t->insertPageBreakEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 34: { WorksheetEntry* _r = _t->insertPageBreakEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 35: { WorksheetEntry* _r = _t->insertLatexEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 36: { WorksheetEntry* _r = _t->insertLatexEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 37: { WorksheetEntry* _r = _t->insertHorizontalRuleEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 38: { WorksheetEntry* _r = _t->insertHorizontalRuleEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 39: { WorksheetEntry* _r = _t->insertHierarchyEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 40: { WorksheetEntry* _r = _t->insertHierarchyEntry();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 41: { WorksheetEntry* _r = _t->insertCommandEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 42: { WorksheetEntry* _r = _t->insertCommandEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 43: { WorksheetEntry* _r = _t->insertTextEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 44: { WorksheetEntry* _r = _t->insertTextEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 45: { WorksheetEntry* _r = _t->insertMarkdownEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 46: { WorksheetEntry* _r = _t->insertMarkdownEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 47: { WorksheetEntry* _r = _t->insertImageEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 48: { WorksheetEntry* _r = _t->insertImageEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 49: { WorksheetEntry* _r = _t->insertPageBreakEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 50: { WorksheetEntry* _r = _t->insertPageBreakEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 51: { WorksheetEntry* _r = _t->insertLatexEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 52: { WorksheetEntry* _r = _t->insertLatexEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 53: { WorksheetEntry* _r = _t->insertHorizontalRuleEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 54: { WorksheetEntry* _r = _t->insertHorizontalRuleEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 55: { WorksheetEntry* _r = _t->insertHierarchyEntryBefore((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 56: { WorksheetEntry* _r = _t->insertHierarchyEntryBefore();
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 57: _t->updateLayout(); break;
        case 58: _t->updateHierarchyLayout(); break;
        case 59: _t->updateHierarchyControlsLayout((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1]))); break;
        case 60: _t->updateHierarchyControlsLayout(); break;
        case 61: _t->updateEntrySize((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1]))); break;
        case 62: _t->print((*reinterpret_cast<std::add_pointer_t<QPrinter*>>(_a[1]))); break;
        case 63: _t->paste(); break;
        case 64: _t->focusEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1]))); break;
        case 65: _t->evaluate(); break;
        case 66: _t->evaluateCurrentEntry(); break;
        case 67: _t->interrupt(); break;
        case 68: _t->interruptCurrentEntryEvaluation(); break;
        case 69: { bool _r = _t->completionEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: _t->showCompletion(); break;
        case 71: _t->initActions(); break;
        case 72: _t->setVariableHighlightingEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 73: _t->enableCompletion((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 74: _t->enableExpressionNumbering((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 75: _t->enableAnimations((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 76: _t->enableEmbeddedMath((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 77: { QDomDocument _r = _t->toXML((*reinterpret_cast<std::add_pointer_t<KZip*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDomDocument*>(_a[0]) = std::move(_r); }  break;
        case 78: { QDomDocument _r = _t->toXML();
            if (_a[0]) *reinterpret_cast<QDomDocument*>(_a[0]) = std::move(_r); }  break;
        case 79: _t->save((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 80: _t->save((*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[1]))); break;
        case 81: { QByteArray _r = _t->saveToByteArray();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 82: _t->savePlain((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 83: _t->saveLatex((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 84: { bool _r = _t->load((*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 85: _t->load((*reinterpret_cast<std::add_pointer_t<QByteArray*>>(_a[1]))); break;
        case 86: { bool _r = _t->load((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 87: _t->gotResult((*reinterpret_cast<std::add_pointer_t<Cantor::Expression*>>(_a[1]))); break;
        case 88: _t->gotResult(); break;
        case 89: _t->removeCurrentEntry(); break;
        case 90: _t->setFirstEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1]))); break;
        case 91: _t->setLastEntry((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1]))); break;
        case 92: _t->invalidateFirstEntry(); break;
        case 93: _t->invalidateLastEntry(); break;
        case 94: _t->updateFocusedTextItem((*reinterpret_cast<std::add_pointer_t<WorksheetTextEditorItem*>>(_a[1]))); break;
        case 95: _t->updateFocusedTextItem((*reinterpret_cast<std::add_pointer_t<WorksheetTextItem*>>(_a[1]))); break;
        case 96: _t->updateDragScrollTimer(); break;
        case 97: _t->registerShortcut((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 98: _t->updateShortcut(); break;
        case 99: _t->setRichTextInformation((*reinterpret_cast<std::add_pointer_t<Worksheet::RichTextInfo>>(_a[1]))); break;
        case 100: _t->setAcceptRichText((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 101: _t->setTextForegroundColor(); break;
        case 102: _t->setTextBackgroundColor(); break;
        case 103: _t->setTextBold((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 104: _t->setTextItalic((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 105: _t->setTextUnderline((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 106: _t->setTextStrikeOut((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 107: _t->setAlignLeft(); break;
        case 108: _t->setAlignRight(); break;
        case 109: _t->setAlignCenter(); break;
        case 110: _t->setAlignJustify(); break;
        case 111: _t->setFontFamily((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 112: _t->setFontSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 113: _t->changeEntryType((*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 114: _t->collapseSelectionResults(); break;
        case 115: _t->collapseAllResults(); break;
        case 116: _t->uncollapseSelectionResults(); break;
        case 117: _t->uncollapseAllResults(); break;
        case 118: _t->removeSelectionResults(); break;
        case 119: _t->removeAllResults(); break;
        case 120: _t->addToExectuionSelection(); break;
        case 121: _t->excludeFromExecutionSelection(); break;
        case 122: _t->requestScrollToHierarchyEntry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 123: _t->clearAllSelections(); break;
        case 124: _t->handleSettingsChanges(); break;
        case 125: { WorksheetEntry* _r = _t->appendEntry((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 126: { WorksheetEntry* _r = _t->appendEntry((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 127: { WorksheetEntry* _r = _t->insertEntry((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 128: { WorksheetEntry* _r = _t->insertEntry((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 129: { WorksheetEntry* _r = _t->insertEntryBefore((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<WorksheetEntry*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 130: { WorksheetEntry* _r = _t->insertEntryBefore((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<WorksheetEntry**>(_a[0]) = std::move(_r); }  break;
        case 131: _t->selectionRemove(); break;
        case 132: _t->selectionEvaluate(); break;
        case 133: _t->selectionMoveUp(); break;
        case 134: _t->selectionMoveDown(); break;
        case 135: _t->animateEntryCursor(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::modified, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::loaded, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(const QString & )>(_a, &Worksheet::showHelp, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(const QStringList & , const QStringList & , const QList<int> & )>(_a, &Worksheet::hierarchyChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(QString , QString , int )>(_a, &Worksheet::hierarhyEntryNameChange, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::updatePrompt, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(bool )>(_a, &Worksheet::undoAvailable, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(bool )>(_a, &Worksheet::redoAvailable, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::undo, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::redo, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(bool )>(_a, &Worksheet::cutAvailable, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(bool )>(_a, &Worksheet::copyAvailable, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(bool )>(_a, &Worksheet::pasteAvailable, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::cut, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)()>(_a, &Worksheet::copy, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Worksheet::*)(const QString & )>(_a, &Worksheet::requestDocumentation, 15))
            return;
    }
}

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

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

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

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

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

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

// SIGNAL 3
void Worksheet::hierarchyChanged(const QStringList & _t1, const QStringList & _t2, const QList<int> & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2, _t3);
}

// SIGNAL 4
void Worksheet::hierarhyEntryNameChange(QString _t1, QString _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2, _t3);
}

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

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

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

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

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

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

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

// SIGNAL 12
void Worksheet::pasteAvailable(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

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

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

// SIGNAL 15
void Worksheet::requestDocumentation(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}
QT_WARNING_POP
