/****************************************************************************
** Meta object code from reading C++ file 'DkWidgets.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/DkWidgets.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 'DkWidgets.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_ZN3nmc8DkButtonE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkButton::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QPushButton::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc13DkRatingLabelE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkRatingLabel::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkRatingLabelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkRatingLabel",
        "ratingEdited",
        "",
        "rating"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'ratingEdited'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkRatingLabel, qt_meta_tag_ZN3nmc13DkRatingLabelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkRatingLabel::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkRatingLabelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkRatingLabelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkRatingLabelE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkRatingLabel::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 < 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::DkRatingLabel::ratingEdited(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc15DkFileInfoLabelE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkFileInfoLabel::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkFileInfoLabelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkFileInfoLabel",
        "ratingEdited",
        "",
        "rating",
        "setVisible",
        "visible",
        "saveSettings"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'ratingEdited'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool, bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 5 }, { QMetaType::Bool, 6 },
        }}),
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool)>(4, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkFileInfoLabel, qt_meta_tag_ZN3nmc15DkFileInfoLabelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkFileInfoLabel::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeLabel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkFileInfoLabelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkFileInfoLabelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc15DkFileInfoLabelE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkFileInfoLabel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkFadeLabel::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::DkFileInfoLabel::ratingEdited(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc8DkPlayerE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkPlayer::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc8DkPlayerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkPlayer",
        "nextSignal",
        "",
        "previousSignal",
        "play",
        "togglePlay",
        "startTimer",
        "autoNext",
        "next",
        "previous",
        "showTemporarily",
        "autoHide",
        "isPlaying"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'nextSignal'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'previousSignal'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'play'
        QtMocHelpers::SlotData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Slot 'togglePlay'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'startTimer'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'autoNext'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'next'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'previous'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showTemporarily'
        QtMocHelpers::SlotData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'showTemporarily'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'isPlaying'
        QtMocHelpers::SlotData<bool() const>(12, 2, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkPlayer, qt_meta_tag_ZN3nmc8DkPlayerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkPlayer::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc8DkPlayerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc8DkPlayerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc8DkPlayerE_t>.metaTypes,
    nullptr
} };

void nmc::DkPlayer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkPlayer *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->nextSignal(); break;
        case 1: _t->previousSignal(); break;
        case 2: _t->play((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->togglePlay(); break;
        case 4: _t->startTimer(); break;
        case 5: _t->autoNext(); break;
        case 6: _t->next(); break;
        case 7: _t->previous(); break;
        case 8: _t->showTemporarily((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->showTemporarily(); break;
        case 10: { bool _r = _t->isPlaying();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkPlayer::*)()>(_a, &DkPlayer::nextSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkPlayer::*)()>(_a, &DkPlayer::previousSignal, 1))
            return;
    }
}

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

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

int nmc::DkPlayer::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 < 11)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 11)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 11;
    }
    return _id;
}

// SIGNAL 0
void nmc::DkPlayer::nextSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void nmc::DkPlayer::previousSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkFolderScrollBar::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkFolderScrollBar",
        "loadFileSignal",
        "",
        "idx",
        "visibleSignal",
        "visible",
        "updateDir",
        "QList<QSharedPointer<DkImageContainerT>>",
        "images",
        "updateFile"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(int) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Signal 'visibleSignal'
        QtMocHelpers::SignalData<void(bool) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 5 },
        }}),
        // Slot 'updateDir'
        QtMocHelpers::SlotData<void(QVector<QSharedPointer<DkImageContainerT>>)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Slot 'updateFile'
        QtMocHelpers::SlotData<void(int)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkFolderScrollBar, qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkFolderScrollBar::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeMixin<QSlider>::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t>.metaTypes,
    nullptr
} };

void nmc::DkFolderScrollBar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkFolderScrollBar *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadFileSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 1: _t->visibleSignal((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->updateDir((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<DkImageContainerT>>>>(_a[1]))); break;
        case 3: _t->updateFile((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            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 (DkFolderScrollBar::*)(int ) const>(_a, &DkFolderScrollBar::loadFileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkFolderScrollBar::*)(bool ) const>(_a, &DkFolderScrollBar::visibleSignal, 1))
            return;
    }
}

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

void *nmc::DkFolderScrollBar::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkFolderScrollBarE_t>.strings))
        return static_cast<void*>(this);
    return DkFadeMixin<QSlider>::qt_metacast(_clname);
}

int nmc::DkFolderScrollBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkFadeMixin<QSlider>::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)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    return _id;
}

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

// SIGNAL 1
void nmc::DkFolderScrollBar::visibleSignal(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkFolderScrollBar *>(this), &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc13DkThumbsSaverE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkThumbsSaver::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkThumbsSaverE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkThumbsSaver",
        "numFilesSignal",
        "",
        "currentFileIdx",
        "stopProgress",
        "thumbLoaded"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'numFilesSignal'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'stopProgress'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'thumbLoaded'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkThumbsSaver, qt_meta_tag_ZN3nmc13DkThumbsSaverE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkThumbsSaver::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkThumbsSaverE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkThumbsSaverE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkThumbsSaverE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkThumbsSaver::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 < 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::DkThumbsSaver::numFilesSignal(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc17DkFileSystemModelE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkFileSystemModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QFileSystemModel::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc20DkSortFileProxyModelE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkSortFileProxyModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSortFilterProxyModel::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc10DkExplorerE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkExplorer::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc10DkExplorerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkExplorer",
        "openFile",
        "",
        "filePath",
        "openDir",
        "dir",
        "setCurrentImage",
        "QSharedPointer<DkImageContainerT>",
        "img",
        "setCurrentPath",
        "path",
        "fileClicked",
        "QModelIndex",
        "index",
        "showColumn",
        "show",
        "setEditable",
        "editable",
        "adjustColumnWidth",
        "enableLoadSelected",
        "enable",
        "openSelected"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'openFile'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'openDir'
        QtMocHelpers::SignalData<void(const QString &) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'setCurrentImage'
        QtMocHelpers::SlotData<void(QSharedPointer<DkImageContainerT>)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Slot 'setCurrentPath'
        QtMocHelpers::SlotData<void(const QString &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 10 },
        }}),
        // Slot 'fileClicked'
        QtMocHelpers::SlotData<void(const QModelIndex &) const>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 },
        }}),
        // Slot 'showColumn'
        QtMocHelpers::SlotData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 15 },
        }}),
        // Slot 'setEditable'
        QtMocHelpers::SlotData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'adjustColumnWidth'
        QtMocHelpers::SlotData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'enableLoadSelected'
        QtMocHelpers::SlotData<void(bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 20 },
        }}),
        // Slot 'openSelected'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkExplorer, qt_meta_tag_ZN3nmc10DkExplorerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkExplorer::staticMetaObject = { {
    QMetaObject::SuperData::link<DkDockWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc10DkExplorerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc10DkExplorerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc10DkExplorerE_t>.metaTypes,
    nullptr
} };

void nmc::DkExplorer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkExplorer *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->openFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->openDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->setCurrentImage((*reinterpret_cast<std::add_pointer_t<QSharedPointer<DkImageContainerT>>>(_a[1]))); break;
        case 3: _t->setCurrentPath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->fileClicked((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 5: _t->showColumn((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->setEditable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->adjustColumnWidth(); break;
        case 8: _t->enableLoadSelected((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->openSelected(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            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 (DkExplorer::*)(const QString & ) const>(_a, &DkExplorer::openFile, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkExplorer::*)(const QString & ) const>(_a, &DkExplorer::openDir, 1))
            return;
    }
}

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

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

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

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

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

template <> constexpr inline auto nmc::DkBrowseExplorer::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc16DkBrowseExplorerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBrowseExplorer",
        "browseClicked",
        "",
        "scrollToCurrentClicked",
        "setRootPath",
        "root"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'browseClicked'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'scrollToCurrentClicked'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setRootPath'
        QtMocHelpers::SlotData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBrowseExplorer, qt_meta_tag_ZN3nmc16DkBrowseExplorerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBrowseExplorer::staticMetaObject = { {
    QMetaObject::SuperData::link<DkExplorer::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkBrowseExplorerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkBrowseExplorerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc16DkBrowseExplorerE_t>.metaTypes,
    nullptr
} };

void nmc::DkBrowseExplorer::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkBrowseExplorer *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->browseClicked(); break;
        case 1: _t->scrollToCurrentClicked(); break;
        case 2: _t->setRootPath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
}

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

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

int nmc::DkBrowseExplorer::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkExplorer::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_ZN3nmc10DkOverviewE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkOverview::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QLabel::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc12DkZoomWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkZoomWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkZoomWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkZoomWidget",
        "zoomSignal",
        "",
        "zoomLevel",
        "updateZoom",
        "onSbZoomValueChanged",
        "onSlZoomValueChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'zoomSignal'
        QtMocHelpers::SignalData<void(double)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Slot 'updateZoom'
        QtMocHelpers::SlotData<void(double)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Slot 'onSbZoomValueChanged'
        QtMocHelpers::SlotData<void(double)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Slot 'onSlZoomValueChanged'
        QtMocHelpers::SlotData<void(int)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkZoomWidget, qt_meta_tag_ZN3nmc12DkZoomWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkZoomWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeLabel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkZoomWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkZoomWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc12DkZoomWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkZoomWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkZoomWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->zoomSignal((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 1: _t->updateZoom((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 2: _t->onSbZoomValueChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 3: _t->onSlZoomValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkZoomWidget::*)(double )>(_a, &DkZoomWidget::zoomSignal, 0))
            return;
    }
}

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

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

int nmc::DkZoomWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkFadeLabel::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::DkZoomWidget::zoomSignal(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc15DkTransformRectE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkTransformRect::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkTransformRectE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkTransformRect",
        "ctrlMovedSignal",
        "",
        "QPointF",
        "Qt::KeyboardModifiers",
        "updateDiagonal"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'ctrlMovedSignal'
        QtMocHelpers::SignalData<void(int, const QPointF &, Qt::KeyboardModifiers, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 }, { 0x80000000 | 3, 2 }, { 0x80000000 | 4, 2 }, { QMetaType::Bool, 2 },
        }}),
        // Signal 'updateDiagonal'
        QtMocHelpers::SignalData<void(int)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkTransformRect, qt_meta_tag_ZN3nmc15DkTransformRectE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkTransformRect::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkTransformRectE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkTransformRectE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc15DkTransformRectE_t>.metaTypes,
    nullptr
} };

void nmc::DkTransformRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkTransformRect *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->ctrlMovedSignal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Qt::KeyboardModifiers>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 1: _t->updateDiagonal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkTransformRect::*)(int , const QPointF & , Qt::KeyboardModifiers , bool )>(_a, &DkTransformRect::ctrlMovedSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkTransformRect::*)(int )>(_a, &DkTransformRect::updateDiagonal, 1))
            return;
    }
}

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

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

int nmc::DkTransformRect::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 < 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::DkTransformRect::ctrlMovedSignal(int _t1, const QPointF & _t2, Qt::KeyboardModifiers _t3, bool _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 1
void nmc::DkTransformRect::updateDiagonal(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc14DkEditableRectE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkEditableRect::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc14DkEditableRectE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkEditableRect",
        "cropImageSignal",
        "",
        "DkRotatingRect",
        "cropArea",
        "QColor",
        "bgCol",
        "cropToMetaData",
        "angleSignal",
        "angle",
        "aRatioSignal",
        "QPointF",
        "aRatio",
        "updateRectSignal",
        "QRect",
        "r",
        "updateCorner",
        "idx",
        "point",
        "Qt::KeyboardModifiers",
        "modifier",
        "changeState",
        "updateDiagonal",
        "setFixedDiagonal",
        "DkVector",
        "diag",
        "setAngle",
        "apply",
        "setPanning",
        "panning",
        "setPaintHint",
        "paintMode",
        "setShadingHint",
        "invert",
        "setShowInfo",
        "showInfo",
        "setRect",
        "rect"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'cropImageSignal'
        QtMocHelpers::SignalData<void(const DkRotatingRect &, const QColor &, bool) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { 0x80000000 | 5, 6 }, { QMetaType::Bool, 7 },
        }}),
        // Signal 'cropImageSignal'
        QtMocHelpers::SignalData<void(const DkRotatingRect &, const QColor &) const>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { 0x80000000 | 5, 6 },
        }}),
        // Signal 'cropImageSignal'
        QtMocHelpers::SignalData<void(const DkRotatingRect &) const>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'angleSignal'
        QtMocHelpers::SignalData<void(double) const>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 9 },
        }}),
        // Signal 'aRatioSignal'
        QtMocHelpers::SignalData<void(const QPointF &) const>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Signal 'updateRectSignal'
        QtMocHelpers::SignalData<void(const QRect &) const>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 14, 15 },
        }}),
        // Slot 'updateCorner'
        QtMocHelpers::SlotData<void(int, const QPointF &, Qt::KeyboardModifiers, bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 }, { 0x80000000 | 11, 18 }, { 0x80000000 | 19, 20 }, { QMetaType::Bool, 21 },
        }}),
        // Slot 'updateCorner'
        QtMocHelpers::SlotData<void(int, const QPointF &, Qt::KeyboardModifiers)>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 17 }, { 0x80000000 | 11, 18 }, { 0x80000000 | 19, 20 },
        }}),
        // Slot 'updateDiagonal'
        QtMocHelpers::SlotData<void(int)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'setFixedDiagonal'
        QtMocHelpers::SlotData<void(const DkVector &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 24, 25 },
        }}),
        // Slot 'setAngle'
        QtMocHelpers::SlotData<void(double, bool)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 9 }, { QMetaType::Bool, 27 },
        }}),
        // Slot 'setAngle'
        QtMocHelpers::SlotData<void(double)>(26, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Double, 9 },
        }}),
        // Slot 'setPanning'
        QtMocHelpers::SlotData<void(bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 29 },
        }}),
        // Slot 'setPaintHint'
        QtMocHelpers::SlotData<void(int)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 31 },
        }}),
        // Slot 'setPaintHint'
        QtMocHelpers::SlotData<void()>(30, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setShadingHint'
        QtMocHelpers::SlotData<void(bool)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 33 },
        }}),
        // Slot 'setShowInfo'
        QtMocHelpers::SlotData<void(bool)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 35 },
        }}),
        // Slot 'setRect'
        QtMocHelpers::SlotData<void(const QRect &)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 14, 37 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkEditableRect, qt_meta_tag_ZN3nmc14DkEditableRectE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkEditableRect::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkEditableRectE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkEditableRectE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc14DkEditableRectE_t>.metaTypes,
    nullptr
} };

void nmc::DkEditableRect::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkEditableRect *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->cropImageSignal((*reinterpret_cast<std::add_pointer_t<DkRotatingRect>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 1: _t->cropImageSignal((*reinterpret_cast<std::add_pointer_t<DkRotatingRect>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2]))); break;
        case 2: _t->cropImageSignal((*reinterpret_cast<std::add_pointer_t<DkRotatingRect>>(_a[1]))); break;
        case 3: _t->angleSignal((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 4: _t->aRatioSignal((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 5: _t->updateRectSignal((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1]))); break;
        case 6: _t->updateCorner((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Qt::KeyboardModifiers>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 7: _t->updateCorner((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Qt::KeyboardModifiers>>(_a[3]))); break;
        case 8: _t->updateDiagonal((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->setFixedDiagonal((*reinterpret_cast<std::add_pointer_t<DkVector>>(_a[1]))); break;
        case 10: _t->setAngle((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 11: _t->setAngle((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 12: _t->setPanning((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->setPaintHint((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 14: _t->setPaintHint(); break;
        case 15: _t->setShadingHint((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->setShowInfo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->setRect((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkEditableRect::*)(const DkRotatingRect & , const QColor & , bool ) const>(_a, &DkEditableRect::cropImageSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkEditableRect::*)(double ) const>(_a, &DkEditableRect::angleSignal, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkEditableRect::*)(const QPointF & ) const>(_a, &DkEditableRect::aRatioSignal, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkEditableRect::*)(const QRect & ) const>(_a, &DkEditableRect::updateRectSignal, 5))
            return;
    }
}

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

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

int nmc::DkEditableRect::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 < 18)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 18;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 18)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 18;
    }
    return _id;
}

// SIGNAL 0
void nmc::DkEditableRect::cropImageSignal(const DkRotatingRect & _t1, const QColor & _t2, bool _t3)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkEditableRect *>(this), &staticMetaObject, 0, nullptr, _t1, _t2, _t3);
}

// SIGNAL 3
void nmc::DkEditableRect::angleSignal(double _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkEditableRect *>(this), &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void nmc::DkEditableRect::aRatioSignal(const QPointF & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkEditableRect *>(this), &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void nmc::DkEditableRect::updateRectSignal(const QRect & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkEditableRect *>(this), &staticMetaObject, 5, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc12DkCropWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkCropWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkCropWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkCropWidget",
        "hideSignal",
        "",
        "crop",
        "cropToMetadata",
        "setVisible",
        "visible"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'hideSignal'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'crop'
        QtMocHelpers::SlotData<void(bool)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 4 },
        }}),
        // Slot 'crop'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkCropWidget, qt_meta_tag_ZN3nmc12DkCropWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkCropWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkEditableRect::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkCropWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkCropWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc12DkCropWidgetE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkCropWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkEditableRect::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::DkCropWidget::hideSignal()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc11DkHistogramE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkHistogram::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc11DkHistogramE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkHistogram",
        "onToggleStatsTriggered",
        "",
        "show"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onToggleStatsTriggered'
        QtMocHelpers::SlotData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkHistogram, qt_meta_tag_ZN3nmc11DkHistogramE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkHistogram::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc11DkHistogramE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc11DkHistogramE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc11DkHistogramE_t>.metaTypes,
    nullptr
} };

void nmc::DkHistogram::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkHistogram *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onToggleStatsTriggered((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
}

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

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

int nmc::DkHistogram::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 < 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;
}
namespace {
struct qt_meta_tag_ZN3nmc13DkFolderLabelE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkFolderLabel::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkFolderLabelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkFolderLabel",
        "loadFileSignal",
        ""
    };

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

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

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

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

int nmc::DkFolderLabel::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 < 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::DkFolderLabel::loadFileSignal(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkFolderLabel *>(this), &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc15DkDirectoryEditE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkDirectoryEdit::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkDirectoryEditE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkDirectoryEdit",
        "directoryChanged",
        "",
        "path",
        "lineEditChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'directoryChanged'
        QtMocHelpers::SignalData<bool(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'lineEditChanged'
        QtMocHelpers::SlotData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkDirectoryEdit, qt_meta_tag_ZN3nmc15DkDirectoryEditE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkDirectoryEdit::staticMetaObject = { {
    QMetaObject::SuperData::link<QLineEdit::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkDirectoryEditE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkDirectoryEditE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc15DkDirectoryEditE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkDirectoryEdit::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QLineEdit::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
bool nmc::DkDirectoryEdit::directoryChanged(const QString & _t1)
{
    bool _t0{};
    QMetaObject::activate<bool>(this, &staticMetaObject, 0, std::addressof(_t0), _t1);
    return _t0;
}
namespace {
struct qt_meta_tag_ZN3nmc18DkDirectoryChooserE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkDirectoryChooser::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc18DkDirectoryChooserE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkDirectoryChooser",
        "directoryChanged",
        "",
        "dirPath",
        "onDirButtonClicked"
    };

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

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

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

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

int nmc::DkDirectoryChooser::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 < 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::DkDirectoryChooser::directoryChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkDirectoryChooser *>(this), &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc13DkDelayedInfoE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkDelayedInfo::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkDelayedInfoE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkDelayedInfo",
        "infoSignal",
        "",
        "time",
        "sendInfo"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'infoSignal'
        QtMocHelpers::SignalData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'sendInfo'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessProtected, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkDelayedInfo, qt_meta_tag_ZN3nmc13DkDelayedInfoE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkDelayedInfo::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkDelayedInfoE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkDelayedInfoE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkDelayedInfoE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkDelayedInfo::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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::DkDelayedInfo::infoSignal(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc16DkDelayedMessageE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkDelayedMessage::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc16DkDelayedMessageE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkDelayedMessage",
        "infoSignal",
        "",
        "msg",
        "time"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'infoSignal'
        QtMocHelpers::SignalData<void(const QString &, int) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Int, 4 },
        }}),
        // Signal 'infoSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkDelayedMessage, qt_meta_tag_ZN3nmc16DkDelayedMessageE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkDelayedMessage::staticMetaObject = { {
    QMetaObject::SuperData::link<DkDelayedInfo::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkDelayedMessageE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkDelayedMessageE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc16DkDelayedMessageE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto nmc::DkListWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkListWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkListWidget",
        "dataDroppedSignal",
        ""
    };

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

void nmc::DkListWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkListWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->dataDroppedSignal(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkListWidget::*)() const>(_a, &DkListWidget::dataDroppedSignal, 0))
            return;
    }
}

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

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

int nmc::DkListWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QListWidget::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::DkListWidget::dataDroppedSignal()const
{
    QMetaObject::activate(const_cast< nmc::DkListWidget *>(this), &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc13DkProgressBarE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkProgressBar::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkProgressBarE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkProgressBar",
        "setVisible",
        "",
        "visible",
        "setVisibleTimed",
        "time"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'setVisibleTimed'
        QtMocHelpers::SlotData<void(bool, int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 }, { QMetaType::Int, 5 },
        }}),
        // Slot 'setVisibleTimed'
        QtMocHelpers::SlotData<void(bool)>(4, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkProgressBar, qt_meta_tag_ZN3nmc13DkProgressBarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkProgressBar::staticMetaObject = { {
    QMetaObject::SuperData::link<QProgressBar::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkProgressBarE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkProgressBarE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkProgressBarE_t>.metaTypes,
    nullptr
} };

void nmc::DkProgressBar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkProgressBar *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->setVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->setVisibleTimed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 2: _t->setVisibleTimed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
}

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

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

int nmc::DkProgressBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QProgressBar::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_ZN3nmc16DkTabEntryWidgetE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkTabEntryWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QPushButton::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc15DkDisplayWidgetE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkDisplayWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkWidget::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
