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

#include "../../../OpenBoard/src/document/UBDocumentController.h"
#include <QtGui/qtextcursor.h>
#include <QtGui/qscreen.h>
#include <QtNetwork/QSslPreSharedKeyAuthenticator>
#include <QtNetwork/QSslError>
#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 'UBDocumentController.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto UBDocumentReplaceDialog::qt_create_metaobjectdata<qt_meta_tag_ZN23UBDocumentReplaceDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UBDocumentReplaceDialog",
        "createNewFolder",
        "",
        "str",
        "closeDialog",
        "replaceAll",
        "skip",
        "accept",
        "reject",
        "reactOnTextChanged",
        "pStr"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'createNewFolder'
        QtMocHelpers::SignalData<void(QString)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'closeDialog'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'replaceAll'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'skip'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'reject'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'reactOnTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(9, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 10 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UBDocumentReplaceDialog, qt_meta_tag_ZN23UBDocumentReplaceDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject UBDocumentReplaceDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23UBDocumentReplaceDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23UBDocumentReplaceDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23UBDocumentReplaceDialogE_t>.metaTypes,
    nullptr
} };

void UBDocumentReplaceDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UBDocumentReplaceDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->createNewFolder((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->closeDialog(); break;
        case 2: _t->replaceAll(); break;
        case 3: _t->skip(); break;
        case 4: _t->accept(); break;
        case 5: _t->reject(); break;
        case 6: _t->reactOnTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (UBDocumentReplaceDialog::*)(QString )>(_a, &UBDocumentReplaceDialog::createNewFolder, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (UBDocumentReplaceDialog::*)()>(_a, &UBDocumentReplaceDialog::closeDialog, 1))
            return;
    }
}

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

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

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

// SIGNAL 0
void UBDocumentReplaceDialog::createNewFolder(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void UBDocumentReplaceDialog::closeDialog()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN19UBDocumentTreeModelE_t {};
} // unnamed namespace

template <> constexpr inline auto UBDocumentTreeModel::qt_create_metaobjectdata<qt_meta_tag_ZN19UBDocumentTreeModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UBDocumentTreeModel",
        "indexChanged",
        "",
        "QModelIndex",
        "newIndex",
        "oldIndex",
        "currentIndexMoved",
        "previous"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'indexChanged'
        QtMocHelpers::SignalData<void(const QModelIndex &, const QModelIndex &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { 0x80000000 | 3, 5 },
        }}),
        // Signal 'currentIndexMoved'
        QtMocHelpers::SignalData<void(const QModelIndex &, const QModelIndex &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { 0x80000000 | 3, 7 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UBDocumentTreeModel, qt_meta_tag_ZN19UBDocumentTreeModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject UBDocumentTreeModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractItemModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19UBDocumentTreeModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19UBDocumentTreeModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19UBDocumentTreeModelE_t>.metaTypes,
    nullptr
} };

void UBDocumentTreeModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UBDocumentTreeModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->indexChanged((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2]))); break;
        case 1: _t->currentIndexMoved((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (UBDocumentTreeModel::*)(const QModelIndex & , const QModelIndex & )>(_a, &UBDocumentTreeModel::indexChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (UBDocumentTreeModel::*)(const QModelIndex & , const QModelIndex & )>(_a, &UBDocumentTreeModel::currentIndexMoved, 1))
            return;
    }
}

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

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

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

// SIGNAL 0
void UBDocumentTreeModel::indexChanged(const QModelIndex & _t1, const QModelIndex & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void UBDocumentTreeModel::currentIndexMoved(const QModelIndex & _t1, const QModelIndex & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}
namespace {
struct qt_meta_tag_ZN22UBDocumentTreeMimeDataE_t {};
} // unnamed namespace

template <> constexpr inline auto UBDocumentTreeMimeData::qt_create_metaobjectdata<qt_meta_tag_ZN22UBDocumentTreeMimeDataE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UBDocumentTreeMimeData"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UBDocumentTreeMimeData, qt_meta_tag_ZN22UBDocumentTreeMimeDataE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject UBDocumentTreeMimeData::staticMetaObject = { {
    QMetaObject::SuperData::link<QMimeData::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22UBDocumentTreeMimeDataE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22UBDocumentTreeMimeDataE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22UBDocumentTreeMimeDataE_t>.metaTypes,
    nullptr
} };

void UBDocumentTreeMimeData::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UBDocumentTreeMimeData *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

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

int UBDocumentTreeMimeData::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QMimeData::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18UBDocumentTreeViewE_t {};
} // unnamed namespace

template <> constexpr inline auto UBDocumentTreeView::qt_create_metaobjectdata<qt_meta_tag_ZN18UBDocumentTreeViewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UBDocumentTreeView",
        "setSelectedAndExpanded",
        "",
        "QModelIndex",
        "pIndex",
        "pExpand",
        "pEdit",
        "onModelIndexChanged",
        "pNewIndex",
        "pOldIndex",
        "hSliderRangeChanged",
        "min",
        "max"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'setSelectedAndExpanded'
        QtMocHelpers::SlotData<void(const QModelIndex &, bool, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Bool, 5 }, { QMetaType::Bool, 6 },
        }}),
        // Slot 'setSelectedAndExpanded'
        QtMocHelpers::SlotData<void(const QModelIndex &, bool)>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Bool, 5 },
        }}),
        // Slot 'setSelectedAndExpanded'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'onModelIndexChanged'
        QtMocHelpers::SlotData<void(const QModelIndex &, const QModelIndex &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 8 }, { 0x80000000 | 3, 9 },
        }}),
        // Slot 'hSliderRangeChanged'
        QtMocHelpers::SlotData<void(int, int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 }, { QMetaType::Int, 12 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UBDocumentTreeView, qt_meta_tag_ZN18UBDocumentTreeViewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject UBDocumentTreeView::staticMetaObject = { {
    QMetaObject::SuperData::link<QTreeView::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18UBDocumentTreeViewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18UBDocumentTreeViewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18UBDocumentTreeViewE_t>.metaTypes,
    nullptr
} };

void UBDocumentTreeView::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UBDocumentTreeView *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->setSelectedAndExpanded((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 1: _t->setSelectedAndExpanded((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 2: _t->setSelectedAndExpanded((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 3: _t->onModelIndexChanged((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2]))); break;
        case 4: _t->hSliderRangeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        default: ;
        }
    }
}

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

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

int UBDocumentTreeView::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QTreeView::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN26UBDocumentTreeItemDelegateE_t {};
} // unnamed namespace

template <> constexpr inline auto UBDocumentTreeItemDelegate::qt_create_metaobjectdata<qt_meta_tag_ZN26UBDocumentTreeItemDelegateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UBDocumentTreeItemDelegate",
        "commitAndCloseEditor",
        "",
        "processChangedText",
        "str",
        "validateString"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'commitAndCloseEditor'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'processChangedText'
        QtMocHelpers::SlotData<void(const QString &) const>(3, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'validateString'
        QtMocHelpers::SlotData<bool(const QString &) const>(5, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { QMetaType::QString, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UBDocumentTreeItemDelegate, qt_meta_tag_ZN26UBDocumentTreeItemDelegateE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject UBDocumentTreeItemDelegate::staticMetaObject = { {
    QMetaObject::SuperData::link<QStyledItemDelegate::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26UBDocumentTreeItemDelegateE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26UBDocumentTreeItemDelegateE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26UBDocumentTreeItemDelegateE_t>.metaTypes,
    nullptr
} };

void UBDocumentTreeItemDelegate::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UBDocumentTreeItemDelegate *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->commitAndCloseEditor(); break;
        case 1: _t->processChangedText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: { bool _r = _t->validateString((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int UBDocumentTreeItemDelegate::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QStyledItemDelegate::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN20UBDocumentControllerE_t {};
} // unnamed namespace

template <> constexpr inline auto UBDocumentController::qt_create_metaobjectdata<qt_meta_tag_ZN20UBDocumentControllerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "UBDocumentController",
        "exportDone",
        "",
        "reorderDocumentsRequested",
        "createNewDocument",
        "refreshDateColumns",
        "reorderDocuments",
        "createNewDocumentInUntitledFolder",
        "createNewDocumentGroup",
        "deleteSelectedItem",
        "deleteSingleItem",
        "QModelIndex",
        "index",
        "UBDocumentTreeModel*",
        "docModel",
        "deleteMultipleItems",
        "QModelIndexList",
        "indexes",
        "emptyFolder",
        "DeletionType",
        "pDeletionType",
        "deleteIndexAndAssociatedData",
        "pIndex",
        "renameSelectedItem",
        "openSelectedItem",
        "duplicateSelectedItem",
        "importFile",
        "selectDocument",
        "std::shared_ptr<UBDocumentProxy>",
        "proxy",
        "setAsCurrentDocument",
        "onImport",
        "editMode",
        "show",
        "hide",
        "showMessage",
        "message",
        "showSpinningWheel",
        "hideMessage",
        "toggleDocumentToolsPalette",
        "cut",
        "copy",
        "paste",
        "focusChanged",
        "QWidget*",
        "old",
        "current",
        "updateExportSubActions",
        "selectedIndex",
        "currentIndexMoved",
        "newIndex",
        "PreviousIndex",
        "onSortKindChanged",
        "onSortOrderChanged",
        "order",
        "onSplitterMoved",
        "size",
        "collapseAll",
        "expandAll",
        "TreeViewSelectionChanged",
        "previous",
        "QItemSelection",
        "selected",
        "deselected",
        "pageSelectionChanged",
        "documentZoomSliderValueChanged",
        "value",
        "itemSelectionChanged",
        "LastSelectedElementType",
        "newSelection",
        "exportDocument",
        "exportDocumentSet",
        "thumbnailViewResized",
        "updateActions",
        "documentSceneChanged",
        "pSceneIndex",
        "thumbnailPageDoubleClicked",
        "QGraphicsItem*",
        "item",
        "pageClicked",
        "toggleAddDocumentToFavorites",
        "addToDocument",
        "addFolderOfImages",
        "addFileToDocument",
        "addImages"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'exportDone'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'reorderDocumentsRequested'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createNewDocument'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'refreshDateColumns'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reorderDocuments'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createNewDocumentInUntitledFolder'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'createNewDocumentGroup'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deleteSelectedItem'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deleteSingleItem'
        QtMocHelpers::SlotData<void(QModelIndex, UBDocumentTreeModel *)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 }, { 0x80000000 | 13, 14 },
        }}),
        // Slot 'deleteMultipleItems'
        QtMocHelpers::SlotData<void(QModelIndexList, UBDocumentTreeModel *)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 }, { 0x80000000 | 13, 14 },
        }}),
        // Slot 'emptyFolder'
        QtMocHelpers::SlotData<void(const QModelIndex &, enum DeletionType)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 }, { 0x80000000 | 19, 20 },
        }}),
        // Slot 'emptyFolder'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(18, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Slot 'deleteIndexAndAssociatedData'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 22 },
        }}),
        // Slot 'renameSelectedItem'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openSelectedItem'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'duplicateSelectedItem'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'importFile'
        QtMocHelpers::SlotData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectDocument'
        QtMocHelpers::SlotData<void(std::shared_ptr<UBDocumentProxy>, bool, const bool, const bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { QMetaType::Bool, 30 }, { QMetaType::Bool, 31 }, { QMetaType::Bool, 32 },
        }}),
        // Slot 'selectDocument'
        QtMocHelpers::SlotData<void(std::shared_ptr<UBDocumentProxy>, bool, const bool)>(27, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { QMetaType::Bool, 30 }, { QMetaType::Bool, 31 },
        }}),
        // Slot 'selectDocument'
        QtMocHelpers::SlotData<void(std::shared_ptr<UBDocumentProxy>, bool)>(27, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { QMetaType::Bool, 30 },
        }}),
        // Slot 'selectDocument'
        QtMocHelpers::SlotData<void(std::shared_ptr<UBDocumentProxy>)>(27, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 28, 29 },
        }}),
        // Slot 'show'
        QtMocHelpers::SlotData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'hide'
        QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showMessage'
        QtMocHelpers::SlotData<void(const QString &, bool)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 }, { QMetaType::Bool, 37 },
        }}),
        // Slot 'showMessage'
        QtMocHelpers::SlotData<void(const QString &)>(35, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'hideMessage'
        QtMocHelpers::SlotData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleDocumentToolsPalette'
        QtMocHelpers::SlotData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'cut'
        QtMocHelpers::SlotData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'copy'
        QtMocHelpers::SlotData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'paste'
        QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'focusChanged'
        QtMocHelpers::SlotData<void(QWidget *, QWidget *)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 44, 45 }, { 0x80000000 | 44, 46 },
        }}),
        // Slot 'updateExportSubActions'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 48 },
        }}),
        // Slot 'currentIndexMoved'
        QtMocHelpers::SlotData<void(const QModelIndex &, const QModelIndex &)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 50 }, { 0x80000000 | 11, 51 },
        }}),
        // Slot 'onSortKindChanged'
        QtMocHelpers::SlotData<void(int)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 12 },
        }}),
        // Slot 'onSortOrderChanged'
        QtMocHelpers::SlotData<void(bool)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'onSplitterMoved'
        QtMocHelpers::SlotData<void(int, int)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 56 }, { QMetaType::Int, 12 },
        }}),
        // Slot 'collapseAll'
        QtMocHelpers::SlotData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'expandAll'
        QtMocHelpers::SlotData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'TreeViewSelectionChanged'
        QtMocHelpers::SlotData<void(const QModelIndex &, const QModelIndex &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 46 }, { 0x80000000 | 11, 60 },
        }}),
        // Slot 'TreeViewSelectionChanged'
        QtMocHelpers::SlotData<void(const QItemSelection &, const QItemSelection &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 61, 62 }, { 0x80000000 | 61, 63 },
        }}),
        // Slot 'pageSelectionChanged'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'documentZoomSliderValueChanged'
        QtMocHelpers::SlotData<void(int)>(65, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 66 },
        }}),
        // Slot 'itemSelectionChanged'
        QtMocHelpers::SlotData<void(enum LastSelectedElementType)>(67, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 68, 69 },
        }}),
        // Slot 'exportDocument'
        QtMocHelpers::SlotData<void()>(70, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'exportDocumentSet'
        QtMocHelpers::SlotData<void()>(71, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'thumbnailViewResized'
        QtMocHelpers::SlotData<void()>(72, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateActions'
        QtMocHelpers::SlotData<void()>(73, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'documentSceneChanged'
        QtMocHelpers::SlotData<void(std::shared_ptr<UBDocumentProxy>, int)>(74, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { QMetaType::Int, 75 },
        }}),
        // Slot 'thumbnailPageDoubleClicked'
        QtMocHelpers::SlotData<void(QGraphicsItem *, int)>(76, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 77, 78 }, { QMetaType::Int, 12 },
        }}),
        // Slot 'pageClicked'
        QtMocHelpers::SlotData<void(QGraphicsItem *, int)>(79, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 77, 78 }, { QMetaType::Int, 12 },
        }}),
        // Slot 'toggleAddDocumentToFavorites'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addToDocument'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addFolderOfImages'
        QtMocHelpers::SlotData<void()>(82, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addFileToDocument'
        QtMocHelpers::SlotData<void()>(83, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'addImages'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UBDocumentController, qt_meta_tag_ZN20UBDocumentControllerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject UBDocumentController::staticMetaObject = { {
    QMetaObject::SuperData::link<UBDocumentContainer::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20UBDocumentControllerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20UBDocumentControllerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20UBDocumentControllerE_t>.metaTypes,
    nullptr
} };

void UBDocumentController::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UBDocumentController *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->exportDone(); break;
        case 1: _t->reorderDocumentsRequested(); break;
        case 2: _t->createNewDocument(); break;
        case 3: _t->refreshDateColumns(); break;
        case 4: _t->reorderDocuments(); break;
        case 5: _t->createNewDocumentInUntitledFolder(); break;
        case 6: _t->createNewDocumentGroup(); break;
        case 7: _t->deleteSelectedItem(); break;
        case 8: _t->deleteSingleItem((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<UBDocumentTreeModel*>>(_a[2]))); break;
        case 9: _t->deleteMultipleItems((*reinterpret_cast<std::add_pointer_t<QModelIndexList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<UBDocumentTreeModel*>>(_a[2]))); break;
        case 10: _t->emptyFolder((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum DeletionType>>(_a[2]))); break;
        case 11: _t->emptyFolder((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 12: _t->deleteIndexAndAssociatedData((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 13: _t->renameSelectedItem(); break;
        case 14: _t->openSelectedItem(); break;
        case 15: _t->duplicateSelectedItem(); break;
        case 16: _t->importFile(); break;
        case 17: _t->selectDocument((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<UBDocumentProxy>>>(_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 18: _t->selectDocument((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<UBDocumentProxy>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 19: _t->selectDocument((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<UBDocumentProxy>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 20: _t->selectDocument((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<UBDocumentProxy>>>(_a[1]))); break;
        case 21: _t->show(); break;
        case 22: _t->hide(); break;
        case 23: _t->showMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 24: _t->showMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 25: _t->hideMessage(); break;
        case 26: _t->toggleDocumentToolsPalette(); break;
        case 27: _t->cut(); break;
        case 28: _t->copy(); break;
        case 29: _t->paste(); break;
        case 30: _t->focusChanged((*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QWidget*>>(_a[2]))); break;
        case 31: _t->updateExportSubActions((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 32: _t->currentIndexMoved((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2]))); break;
        case 33: _t->onSortKindChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 34: _t->onSortOrderChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->onSplitterMoved((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 36: _t->collapseAll(); break;
        case 37: _t->expandAll(); break;
        case 38: _t->TreeViewSelectionChanged((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[2]))); break;
        case 39: _t->TreeViewSelectionChanged((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[2]))); break;
        case 40: _t->pageSelectionChanged(); break;
        case 41: _t->documentZoomSliderValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 42: _t->itemSelectionChanged((*reinterpret_cast<std::add_pointer_t<enum LastSelectedElementType>>(_a[1]))); break;
        case 43: _t->exportDocument(); break;
        case 44: _t->exportDocumentSet(); break;
        case 45: _t->thumbnailViewResized(); break;
        case 46: _t->updateActions(); break;
        case 47: _t->documentSceneChanged((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<UBDocumentProxy>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 48: _t->thumbnailPageDoubleClicked((*reinterpret_cast<std::add_pointer_t<QGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 49: _t->pageClicked((*reinterpret_cast<std::add_pointer_t<QGraphicsItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 50: _t->toggleAddDocumentToFavorites(); break;
        case 51: _t->addToDocument(); break;
        case 52: _t->addFolderOfImages(); break;
        case 53: _t->addFileToDocument(); break;
        case 54: _t->addImages(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< UBDocumentTreeModel* >(); break;
            }
            break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QModelIndexList >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< UBDocumentTreeModel* >(); break;
            }
            break;
        case 30:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWidget* >(); break;
            }
            break;
        case 39:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QItemSelection >(); break;
            }
            break;
        case 48:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QGraphicsItem* >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QGraphicsItem* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (UBDocumentController::*)()>(_a, &UBDocumentController::exportDone, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (UBDocumentController::*)()>(_a, &UBDocumentController::reorderDocumentsRequested, 1))
            return;
    }
}

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

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

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

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

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