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

#include "../../../ImageLounge/src/DkGui/DkThumbsWidgets.h"
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QSharedPointer>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto nmc::DkFilePreview::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkFilePreviewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkFilePreview",
        "loadFileSignal",
        "",
        "filePath",
        "changeFileSignal",
        "idx",
        "positionChangeSignal",
        "pos",
        "showThumbsDockSignal",
        "show",
        "moveImages",
        "updateThumbs",
        "QList<QSharedPointer<DkImageContainerT>>",
        "images",
        "setFileInfo",
        "QSharedPointer<DkImageContainerT>",
        "cImage",
        "newPosition"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'changeFileSignal'
        QtMocHelpers::SignalData<void(int) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Signal 'positionChangeSignal'
        QtMocHelpers::SignalData<void(int) const>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 7 },
        }}),
        // Signal 'showThumbsDockSignal'
        QtMocHelpers::SignalData<void(bool) const>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Slot 'moveImages'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateThumbs'
        QtMocHelpers::SlotData<void(QVector<QSharedPointer<DkImageContainerT>>)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 },
        }}),
        // Slot 'setFileInfo'
        QtMocHelpers::SlotData<void(QSharedPointer<DkImageContainerT>)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 16 },
        }}),
        // Slot 'newPosition'
        QtMocHelpers::SlotData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkFilePreview, qt_meta_tag_ZN3nmc13DkFilePreviewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkFilePreview::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkFilePreviewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkFilePreviewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkFilePreviewE_t>.metaTypes,
    nullptr
} };

void nmc::DkFilePreview::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkFilePreview *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadFileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->changeFileSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->positionChangeSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 3: _t->showThumbsDockSignal((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->moveImages(); break;
        case 5: _t->updateThumbs((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<DkImageContainerT>>>>(_a[1]))); break;
        case 6: _t->setFileInfo((*reinterpret_cast<std::add_pointer_t<QSharedPointer<DkImageContainerT>>>(_a[1]))); break;
        case 7: _t->newPosition(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QSharedPointer<DkImageContainerT>> >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QSharedPointer<DkImageContainerT> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkFilePreview::*)(const QString & ) const>(_a, &DkFilePreview::loadFileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkFilePreview::*)(int ) const>(_a, &DkFilePreview::changeFileSignal, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkFilePreview::*)(int ) const>(_a, &DkFilePreview::positionChangeSignal, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkFilePreview::*)(bool ) const>(_a, &DkFilePreview::showThumbsDockSignal, 3))
            return;
    }
}

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

void *nmc::DkFilePreview::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkFilePreviewE_t>.strings))
        return static_cast<void*>(this);
    return DkFadeWidget::qt_metacast(_clname);
}

int nmc::DkFilePreview::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkFadeWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void nmc::DkFilePreview::loadFileSignal(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkFilePreview *>(this), &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void nmc::DkFilePreview::changeFileSignal(int _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkFilePreview *>(this), &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void nmc::DkFilePreview::positionChangeSignal(int _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkFilePreview *>(this), &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void nmc::DkFilePreview::showThumbsDockSignal(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkFilePreview *>(this), &staticMetaObject, 3, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc12DkThumbLabelE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkThumbLabel::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkThumbLabelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkThumbLabel",
        "loadFileSignal",
        "",
        "filePath",
        "newTab",
        "showFileSignal"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &, bool) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Bool, 4 },
        }}),
        // Signal 'showFileSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'showFileSignal'
        QtMocHelpers::SignalData<void() const>(5, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkThumbLabel, qt_meta_tag_ZN3nmc12DkThumbLabelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkThumbLabel::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbLabelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbLabelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc12DkThumbLabelE_t>.metaTypes,
    nullptr
} };

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

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

void *nmc::DkThumbLabel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbLabelE_t>.strings))
        return static_cast<void*>(this);
    return QGraphicsObject::qt_metacast(_clname);
}

int nmc::DkThumbLabel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QGraphicsObject::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;
}

// SIGNAL 0
void nmc::DkThumbLabel::loadFileSignal(const QString & _t1, bool _t2)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkThumbLabel *>(this), &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void nmc::DkThumbLabel::showFileSignal(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkThumbLabel *>(this), &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc12DkThumbSceneE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkThumbScene::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkThumbSceneE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkThumbScene",
        "loadFileSignal",
        "",
        "filePath",
        "newTab",
        "thumbLoadedSignal",
        "updateThumbLabels",
        "cancelLoading",
        "increaseThumbs",
        "decreaseThumbs",
        "toggleSquaredThumbs",
        "squares",
        "toggleThumbLabels",
        "show",
        "resizeThumbs",
        "dx",
        "showFile",
        "selectThumbs",
        "select",
        "from",
        "to",
        "selectThumb",
        "idx",
        "selectAllThumbs",
        "updateThumbs",
        "QList<QSharedPointer<DkImageContainerT>>",
        "thumbs",
        "deleteSelected",
        "copySelected",
        "pasteImages",
        "renameSelected"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &, bool) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Bool, 4 },
        }}),
        // Signal 'thumbLoadedSignal'
        QtMocHelpers::SignalData<void() const>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateThumbLabels'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'cancelLoading'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'increaseThumbs'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'decreaseThumbs'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleSquaredThumbs'
        QtMocHelpers::SlotData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'toggleThumbLabels'
        QtMocHelpers::SlotData<void(bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'resizeThumbs'
        QtMocHelpers::SlotData<void(float)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 15 },
        }}),
        // Slot 'showFile'
        QtMocHelpers::SlotData<void(const QString &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'showFile'
        QtMocHelpers::SlotData<void()>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'selectThumbs'
        QtMocHelpers::SlotData<void(bool, int, int)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 18 }, { QMetaType::Int, 19 }, { QMetaType::Int, 20 },
        }}),
        // Slot 'selectThumbs'
        QtMocHelpers::SlotData<void(bool, int)>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 18 }, { QMetaType::Int, 19 },
        }}),
        // Slot 'selectThumbs'
        QtMocHelpers::SlotData<void(bool)>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 18 },
        }}),
        // Slot 'selectThumbs'
        QtMocHelpers::SlotData<void()>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'selectThumb'
        QtMocHelpers::SlotData<void(int, bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 22 }, { QMetaType::Bool, 18 },
        }}),
        // Slot 'selectThumb'
        QtMocHelpers::SlotData<void(int)>(21, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 22 },
        }}),
        // Slot 'selectAllThumbs'
        QtMocHelpers::SlotData<void(bool)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 18 },
        }}),
        // Slot 'selectAllThumbs'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'updateThumbs'
        QtMocHelpers::SlotData<void(QVector<QSharedPointer<DkImageContainerT>>)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 26 },
        }}),
        // Slot 'deleteSelected'
        QtMocHelpers::SlotData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'copySelected'
        QtMocHelpers::SlotData<void() const>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'pasteImages'
        QtMocHelpers::SlotData<void() const>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'renameSelected'
        QtMocHelpers::SlotData<void() const>(30, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkThumbScene, qt_meta_tag_ZN3nmc12DkThumbSceneE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkThumbScene::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsScene::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbSceneE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbSceneE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc12DkThumbSceneE_t>.metaTypes,
    nullptr
} };

void nmc::DkThumbScene::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkThumbScene *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadFileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 1: _t->thumbLoadedSignal(); break;
        case 2: _t->updateThumbLabels(); break;
        case 3: _t->cancelLoading(); break;
        case 4: _t->increaseThumbs(); break;
        case 5: _t->decreaseThumbs(); break;
        case 6: _t->toggleSquaredThumbs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->toggleThumbLabels((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->resizeThumbs((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 9: _t->showFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 10: _t->showFile(); break;
        case 11: _t->selectThumbs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 12: _t->selectThumbs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 13: _t->selectThumbs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->selectThumbs(); break;
        case 15: _t->selectThumb((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 16: _t->selectThumb((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 17: _t->selectAllThumbs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->selectAllThumbs(); break;
        case 19: _t->updateThumbs((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<DkImageContainerT>>>>(_a[1]))); break;
        case 20: _t->deleteSelected(); break;
        case 21: _t->copySelected(); break;
        case 22: _t->pasteImages(); break;
        case 23: _t->renameSelected(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 19:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QSharedPointer<DkImageContainerT>> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkThumbScene::*)(const QString & , bool ) const>(_a, &DkThumbScene::loadFileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkThumbScene::*)() const>(_a, &DkThumbScene::thumbLoadedSignal, 1))
            return;
    }
}

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

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

int nmc::DkThumbScene::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 < 24)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 24;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 24)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 24;
    }
    return _id;
}

// SIGNAL 0
void nmc::DkThumbScene::loadFileSignal(const QString & _t1, bool _t2)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkThumbScene *>(this), &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void nmc::DkThumbScene::thumbLoadedSignal()const
{
    QMetaObject::activate(const_cast< nmc::DkThumbScene *>(this), &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc12DkThumbsViewE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkThumbsView::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkThumbsViewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkThumbsView",
        "updateDirSignal",
        "",
        "dir"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'updateDirSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkThumbsView, qt_meta_tag_ZN3nmc12DkThumbsViewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkThumbsView::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsView::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbsViewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbsViewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc12DkThumbsViewE_t>.metaTypes,
    nullptr
} };

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

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

void *nmc::DkThumbsView::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkThumbsViewE_t>.strings))
        return static_cast<void*>(this);
    return QGraphicsView::qt_metacast(_clname);
}

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

// SIGNAL 0
void nmc::DkThumbsView::updateDirSignal(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkThumbsView *>(this), &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkThumbScrollWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkThumbScrollWidget",
        "updateDirSignal",
        "",
        "dir",
        "filterChangedSignal",
        "filters",
        "batchProcessFilesSignal",
        "fileList",
        "setVisible",
        "visible",
        "updateThumbs",
        "QList<QSharedPointer<DkImageContainerT>>",
        "thumbs",
        "setDir",
        "dirPath",
        "enableSelectionActions",
        "setFilterFocus",
        "batchProcessFiles",
        "batchPrint",
        "onLoadFileTriggered"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'updateDirSignal'
        QtMocHelpers::SignalData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'filterChangedSignal'
        QtMocHelpers::SignalData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'batchProcessFilesSignal'
        QtMocHelpers::SignalData<void(const QStringList &) const>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 7 },
        }}),
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Slot 'updateThumbs'
        QtMocHelpers::SlotData<void(QVector<QSharedPointer<DkImageContainerT>>)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Slot 'setDir'
        QtMocHelpers::SlotData<void(const QString &)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Slot 'enableSelectionActions'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFilterFocus'
        QtMocHelpers::SlotData<void() const>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'batchProcessFiles'
        QtMocHelpers::SlotData<void() const>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'batchPrint'
        QtMocHelpers::SlotData<void() const>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onLoadFileTriggered'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkThumbScrollWidget, qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkThumbScrollWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkThumbScrollWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkThumbScrollWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->updateDirSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->filterChangedSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->batchProcessFilesSignal((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 3: _t->setVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->updateThumbs((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<DkImageContainerT>>>>(_a[1]))); break;
        case 5: _t->setDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->enableSelectionActions(); break;
        case 7: _t->setFilterFocus(); break;
        case 8: _t->batchProcessFiles(); break;
        case 9: _t->batchPrint(); break;
        case 10: _t->onLoadFileTriggered(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QSharedPointer<DkImageContainerT>> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkThumbScrollWidget::*)(const QString & )>(_a, &DkThumbScrollWidget::updateDirSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkThumbScrollWidget::*)(const QString & )>(_a, &DkThumbScrollWidget::filterChangedSignal, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkThumbScrollWidget::*)(const QStringList & ) const>(_a, &DkThumbScrollWidget::batchProcessFilesSignal, 2))
            return;
    }
}

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

void *nmc::DkThumbScrollWidget::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkThumbScrollWidgetE_t>.strings))
        return static_cast<void*>(this);
    return DkWidget::qt_metacast(_clname);
}

int nmc::DkThumbScrollWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 11)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 11)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    return _id;
}

// SIGNAL 0
void nmc::DkThumbScrollWidget::updateDirSignal(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void nmc::DkThumbScrollWidget::filterChangedSignal(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void nmc::DkThumbScrollWidget::batchProcessFilesSignal(const QStringList & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkThumbScrollWidget *>(this), &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkThumbPreviewLabel::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkThumbPreviewLabel",
        "loadFileSignal",
        "",
        "filePath",
        "newTab",
        "thumbLoaded",
        "QImage",
        "img"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Bool, 4 },
        }}),
        // Slot 'thumbLoaded'
        QtMocHelpers::SlotData<void(const QString &, const QImage &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { 0x80000000 | 6, 7 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkThumbPreviewLabel, qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkThumbPreviewLabel::staticMetaObject = { {
    QMetaObject::SuperData::link<QLabel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t>.metaTypes,
    nullptr
} };

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

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

void *nmc::DkThumbPreviewLabel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkThumbPreviewLabelE_t>.strings))
        return static_cast<void*>(this);
    return QLabel::qt_metacast(_clname);
}

int nmc::DkThumbPreviewLabel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QLabel::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 nmc::DkThumbPreviewLabel::loadFileSignal(const QString & _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}
namespace {
struct qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkRecentDirWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkRecentDirWidget",
        "loadFileSignal",
        "",
        "filePath",
        "newTab",
        "loadDirSignal",
        "removeSignal",
        "onPinClicked",
        "checked",
        "onRemoveClicked",
        "onLoadDirClicked"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Bool, 4 },
        }}),
        // Signal 'loadDirSignal'
        QtMocHelpers::SignalData<void(const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'removeSignal'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onPinClicked'
        QtMocHelpers::SlotData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Slot 'onRemoveClicked'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onLoadDirClicked'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkRecentDirWidget, qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkRecentDirWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkRecentDirWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkRecentDirWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadFileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 1: _t->loadDirSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->removeSignal(); break;
        case 3: _t->onPinClicked((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->onRemoveClicked(); break;
        case 5: _t->onLoadDirClicked(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkRecentDirWidget::*)(const QString & , bool )>(_a, &DkRecentDirWidget::loadFileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkRecentDirWidget::*)(const QString & )>(_a, &DkRecentDirWidget::loadDirSignal, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkRecentDirWidget::*)()>(_a, &DkRecentDirWidget::removeSignal, 2))
            return;
    }
}

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

void *nmc::DkRecentDirWidget::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkRecentDirWidgetE_t>.strings))
        return static_cast<void*>(this);
    return DkWidget::qt_metacast(_clname);
}

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

// SIGNAL 0
void nmc::DkRecentDirWidget::loadFileSignal(const QString & _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void nmc::DkRecentDirWidget::loadDirSignal(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void nmc::DkRecentDirWidget::removeSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkRecentFilesWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkRecentFilesWidget",
        "loadFileSignal",
        "",
        "filePath",
        "newTab",
        "loadDirSignal",
        "entryRemoved",
        "setVisible",
        "visible"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Bool, 4 },
        }}),
        // Signal 'loadDirSignal'
        QtMocHelpers::SignalData<void(const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'entryRemoved'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkRecentFilesWidget, qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkRecentFilesWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkRecentFilesWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkRecentFilesWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadFileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 1: _t->loadDirSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->entryRemoved(); break;
        case 3: _t->setVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkRecentFilesWidget::*)(const QString & , bool )>(_a, &DkRecentFilesWidget::loadFileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkRecentFilesWidget::*)(const QString & )>(_a, &DkRecentFilesWidget::loadDirSignal, 1))
            return;
    }
}

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

void *nmc::DkRecentFilesWidget::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkRecentFilesWidgetE_t>.strings))
        return static_cast<void*>(this);
    return DkWidget::qt_metacast(_clname);
}

int nmc::DkRecentFilesWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkWidget::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 nmc::DkRecentFilesWidget::loadFileSignal(const QString & _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void nmc::DkRecentFilesWidget::loadDirSignal(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
QT_WARNING_POP
