/****************************************************************************
** Meta object code from reading C++ file 'DkDialog.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/DkDialog.h"
#include <QtGui/qtextcursor.h>
#include <QtNetwork/QSslError>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'DkDialog.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_ZN3nmc14DkSplashScreenE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkSplashScreen::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc15DkFileValidatorE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkFileValidator::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QValidator::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc13DkTrainDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkTrainDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkTrainDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkTrainDialog",
        "textChanged",
        "",
        "text",
        "loadFile",
        "filePath",
        "openFile",
        "accept"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'textChanged'
        QtMocHelpers::SlotData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'loadFile'
        QtMocHelpers::SlotData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'loadFile'
        QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'openFile'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkTrainDialog, qt_meta_tag_ZN3nmc13DkTrainDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkTrainDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkTrainDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkTrainDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkTrainDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkTrainDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkTrainDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->textChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->loadFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->loadFile(); break;
        case 3: _t->openFile(); break;
        case 4: _t->accept(); break;
        default: ;
        }
    }
}

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

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

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

template <> constexpr inline auto nmc::DkAppManagerDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc18DkAppManagerDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkAppManagerDialog",
        "openWithSignal",
        "",
        "QAction*",
        "act",
        "onAddButtonClicked",
        "onDeleteButtonClicked",
        "onRunButtonClicked",
        "accept"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'openWithSignal'
        QtMocHelpers::SignalData<void(QAction *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'onAddButtonClicked'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onDeleteButtonClicked'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onRunButtonClicked'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkAppManagerDialog, qt_meta_tag_ZN3nmc18DkAppManagerDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkAppManagerDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc18DkAppManagerDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc18DkAppManagerDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc18DkAppManagerDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkAppManagerDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkAppManagerDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->openWithSignal((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 1: _t->onAddButtonClicked(); break;
        case 2: _t->onDeleteButtonClicked(); break;
        case 3: _t->onRunButtonClicked(); break;
        case 4: _t->accept(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QAction* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkAppManagerDialog::*)(QAction * )>(_a, &DkAppManagerDialog::openWithSignal, 0))
            return;
    }
}

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

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

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

// SIGNAL 0
void nmc::DkAppManagerDialog::openWithSignal(QAction * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc14DkSearchDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkSearchDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc14DkSearchDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkSearchDialog",
        "loadFileSignal",
        "",
        "filePath",
        "filterSignal",
        "onSearchBarTextChanged",
        "text",
        "onFilterButtonPressed",
        "onResultListViewDoubleClicked",
        "QModelIndex",
        "modelIndex",
        "onResultListViewClicked",
        "accept"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFileSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'filterSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'onSearchBarTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'onFilterButtonPressed'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onResultListViewDoubleClicked'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'onResultListViewClicked'
        QtMocHelpers::SlotData<void(const QModelIndex &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkSearchDialog, qt_meta_tag_ZN3nmc14DkSearchDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkSearchDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkSearchDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkSearchDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc14DkSearchDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkSearchDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkSearchDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadFileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->filterSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->onSearchBarTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->onFilterButtonPressed(); break;
        case 4: _t->onResultListViewDoubleClicked((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 5: _t->onResultListViewClicked((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 6: _t->accept(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkSearchDialog::*)(const QString & ) const>(_a, &DkSearchDialog::loadFileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkSearchDialog::*)(const QString & ) const>(_a, &DkSearchDialog::filterSignal, 1))
            return;
    }
}

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

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

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

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

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

template <> constexpr inline auto nmc::DkResizeDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc14DkResizeDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkResizeDialog",
        "onLockButtonDimClicked",
        "",
        "onLockButtonClicked",
        "onWPixelSpinValueChanged",
        "val",
        "onHPixelSpinValueChanged",
        "onWidthSpinValueChanged",
        "onHeightSpinValueChanged",
        "onResolutionSpinValueChanged",
        "onSizeBoxCurrentIndexChanged",
        "idx",
        "onUnitBoxCurrentIndexChanged",
        "onResUnitBoxCurrentIndexChanged",
        "onResampleBoxCurrentIndexChanged",
        "onResampleCheckClicked",
        "onGammaCorrectionClicked",
        "drawPreview",
        "setVisible",
        "visible",
        "accept"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onLockButtonDimClicked'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onLockButtonClicked'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onWPixelSpinValueChanged'
        QtMocHelpers::SlotData<void(double)>(4, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 5 },
        }}),
        // Slot 'onHPixelSpinValueChanged'
        QtMocHelpers::SlotData<void(double)>(6, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 5 },
        }}),
        // Slot 'onWidthSpinValueChanged'
        QtMocHelpers::SlotData<void(double)>(7, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 5 },
        }}),
        // Slot 'onHeightSpinValueChanged'
        QtMocHelpers::SlotData<void(double)>(8, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 5 },
        }}),
        // Slot 'onResolutionSpinValueChanged'
        QtMocHelpers::SlotData<void(double)>(9, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 5 },
        }}),
        // Slot 'onSizeBoxCurrentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(10, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'onUnitBoxCurrentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(12, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'onResUnitBoxCurrentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(13, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'onResampleBoxCurrentIndexChanged'
        QtMocHelpers::SlotData<void(int)>(14, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'onResampleCheckClicked'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onGammaCorrectionClicked'
        QtMocHelpers::SlotData<void()>(16, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'drawPreview'
        QtMocHelpers::SlotData<void()>(17, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setVisible'
        QtMocHelpers::SlotData<void(bool)>(18, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkResizeDialog, qt_meta_tag_ZN3nmc14DkResizeDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkResizeDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkResizeDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkResizeDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc14DkResizeDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkResizeDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkResizeDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onLockButtonDimClicked(); break;
        case 1: _t->onLockButtonClicked(); break;
        case 2: _t->onWPixelSpinValueChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 3: _t->onHPixelSpinValueChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 4: _t->onWidthSpinValueChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 5: _t->onHeightSpinValueChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 6: _t->onResolutionSpinValueChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 7: _t->onSizeBoxCurrentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->onUnitBoxCurrentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->onResUnitBoxCurrentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->onResampleBoxCurrentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->onResampleCheckClicked(); break;
        case 12: _t->onGammaCorrectionClicked(); break;
        case 13: _t->drawPreview(); break;
        case 14: _t->setVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->accept(); break;
        default: ;
        }
    }
}

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

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

int nmc::DkResizeDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 16)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 16;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 16)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 16;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc18DkShortcutDelegateE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkShortcutDelegate::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc18DkShortcutDelegateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkShortcutDelegate",
        "checkDuplicateSignal",
        "",
        "text",
        "item",
        "QKeySequence",
        "keySequence",
        "clearDuplicateSignal",
        "textChanged",
        "keySequenceChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'checkDuplicateSignal'
        QtMocHelpers::SignalData<void(const QString &, void *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::VoidStar, 4 },
        }}),
        // Signal 'checkDuplicateSignal'
        QtMocHelpers::SignalData<void(const QKeySequence &, void *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 }, { QMetaType::VoidStar, 4 },
        }}),
        // Signal 'clearDuplicateSignal'
        QtMocHelpers::SignalData<void() const>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'textChanged'
        QtMocHelpers::SlotData<void(const QString &)>(8, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'textChanged'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void),
        // Slot 'keySequenceChanged'
        QtMocHelpers::SlotData<void(const QKeySequence &)>(9, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkShortcutDelegate, qt_meta_tag_ZN3nmc18DkShortcutDelegateE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkShortcutDelegate::staticMetaObject = { {
    QMetaObject::SuperData::link<QItemDelegate::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc18DkShortcutDelegateE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc18DkShortcutDelegateE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc18DkShortcutDelegateE_t>.metaTypes,
    nullptr
} };

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

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

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

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

// SIGNAL 1
void nmc::DkShortcutDelegate::checkDuplicateSignal(const QKeySequence & _t1, void * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void nmc::DkShortcutDelegate::clearDuplicateSignal()const
{
    QMetaObject::activate(const_cast< nmc::DkShortcutDelegate *>(this), &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc16DkShortcutsModelE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkShortcutsModel::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc16DkShortcutsModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkShortcutsModel",
        "duplicateSignal",
        "",
        "info",
        "checkDuplicate",
        "text",
        "item",
        "QKeySequence",
        "ks",
        "clearDuplicateInfo"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'duplicateSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'checkDuplicate'
        QtMocHelpers::SlotData<void(const QString &, void *)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::VoidStar, 6 },
        }}),
        // Slot 'checkDuplicate'
        QtMocHelpers::SlotData<void(const QKeySequence &, void *)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 }, { QMetaType::VoidStar, 6 },
        }}),
        // Slot 'clearDuplicateInfo'
        QtMocHelpers::SlotData<void() const>(9, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkShortcutsModel, qt_meta_tag_ZN3nmc16DkShortcutsModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkShortcutsModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractItemModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkShortcutsModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkShortcutsModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc16DkShortcutsModelE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkShortcutsModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractItemModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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::DkShortcutsModel::duplicateSignal(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkShortcutsModel *>(this), &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc17DkShortcutsDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkShortcutsDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc17DkShortcutsDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkShortcutsDialog",
        "accept",
        "",
        "contextMenu",
        "QPoint",
        "cur",
        "defaultButtonClicked"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'contextMenu'
        QtMocHelpers::SlotData<void(const QPoint &)>(3, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 4, 5 },
        }}),
        // Slot 'defaultButtonClicked'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessProtected, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkShortcutsDialog, qt_meta_tag_ZN3nmc17DkShortcutsDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkShortcutsDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkShortcutsDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkShortcutsDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc17DkShortcutsDialogE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkShortcutsDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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_ZN3nmc12DkTextDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkTextDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkTextDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkTextDialog",
        "save",
        ""
    };

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

void nmc::DkTextDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkTextDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->save(); break;
        default: ;
        }
    }
    (void)_a;
}

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

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

int nmc::DkTextDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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_ZN3nmc14DkUpdateDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkUpdateDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc14DkUpdateDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkUpdateDialog",
        "startUpdate",
        "",
        "okButtonClicked"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'startUpdate'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'okButtonClicked'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessProtected, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkUpdateDialog, qt_meta_tag_ZN3nmc14DkUpdateDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkUpdateDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkUpdateDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkUpdateDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc14DkUpdateDialogE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto nmc::DkPrintPreviewWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc20DkPrintPreviewWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkPrintPreviewWidget",
        "zoomChanged",
        "",
        "dpiChanged",
        "dpi",
        "paintForPrinting",
        "paintPreview",
        "QPrinter*",
        "printer",
        "changeDpi",
        "value",
        "centerImage",
        "setLandscapeOrientation",
        "setPortraitOrientation"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'zoomChanged'
        QtMocHelpers::SignalData<void() const>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dpiChanged'
        QtMocHelpers::SignalData<void(int)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 4 },
        }}),
        // Slot 'paintForPrinting'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'paintPreview'
        QtMocHelpers::SlotData<void(QPrinter *)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Slot 'changeDpi'
        QtMocHelpers::SlotData<void(int)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 10 },
        }}),
        // Slot 'centerImage'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setLandscapeOrientation'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setPortraitOrientation'
        QtMocHelpers::SlotData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkPrintPreviewWidget, qt_meta_tag_ZN3nmc20DkPrintPreviewWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkPrintPreviewWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<QPrintPreviewWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc20DkPrintPreviewWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc20DkPrintPreviewWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc20DkPrintPreviewWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkPrintPreviewWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkPrintPreviewWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->zoomChanged(); break;
        case 1: _t->dpiChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->paintForPrinting(); break;
        case 3: _t->paintPreview((*reinterpret_cast<std::add_pointer_t<QPrinter*>>(_a[1]))); break;
        case 4: _t->changeDpi((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 5: _t->centerImage(); break;
        case 6: _t->setLandscapeOrientation(); break;
        case 7: _t->setPortraitOrientation(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkPrintPreviewWidget::*)() const>(_a, &DkPrintPreviewWidget::zoomChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkPrintPreviewWidget::*)(int )>(_a, &DkPrintPreviewWidget::dpiChanged, 1))
            return;
    }
}

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

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

int nmc::DkPrintPreviewWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QPrintPreviewWidget::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)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void nmc::DkPrintPreviewWidget::zoomChanged()const
{
    QMetaObject::activate(const_cast< nmc::DkPrintPreviewWidget *>(this), &staticMetaObject, 0, nullptr);
}

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

template <> constexpr inline auto nmc::DkPrintPreviewDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc20DkPrintPreviewDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkPrintPreviewDialog",
        "zoomIn",
        "",
        "zoomOut",
        "updateDpiFactor",
        "dpi",
        "pageSetup",
        "print",
        "zoom",
        "scale",
        "previewFitWidth",
        "previewFitPage"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateDpiFactor'
        QtMocHelpers::SlotData<void(qreal)>(4, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QReal, 5 },
        }}),
        // Slot 'pageSetup'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'print'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'zoom'
        QtMocHelpers::SlotData<void(int)>(8, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 9 },
        }}),
        // Slot 'previewFitWidth'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'previewFitPage'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkPrintPreviewDialog, qt_meta_tag_ZN3nmc20DkPrintPreviewDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkPrintPreviewDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc20DkPrintPreviewDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc20DkPrintPreviewDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc20DkPrintPreviewDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkPrintPreviewDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkPrintPreviewDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->zoomIn(); break;
        case 1: _t->zoomOut(); break;
        case 2: _t->updateDpiFactor((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 3: _t->pageSetup(); break;
        case 4: _t->print(); break;
        case 5: _t->zoom((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 6: _t->previewFitWidth(); break;
        case 7: _t->previewFitPage(); break;
        default: ;
        }
    }
}

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

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

int nmc::DkPrintPreviewDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc15DkOpacityDialogE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkOpacityDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc18DkExportTiffDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkExportTiffDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc18DkExportTiffDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkExportTiffDialog",
        "updateImage",
        "",
        "QImage",
        "img",
        "updateProgress",
        "infoMessage",
        "msg",
        "onOpenButtonPressed",
        "onSaveButtonPressed",
        "onFileEditTextChanged",
        "filename",
        "setFile",
        "filePath",
        "accept",
        "reject",
        "exportImages",
        "saveFilePath",
        "from",
        "to",
        "overwrite",
        "processingFinished"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'updateImage'
        QtMocHelpers::SignalData<void(const QImage &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'updateProgress'
        QtMocHelpers::SignalData<void(int) const>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'infoMessage'
        QtMocHelpers::SignalData<void(const QString &) const>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'onOpenButtonPressed'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onSaveButtonPressed'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onFileEditTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'setFile'
        QtMocHelpers::SlotData<void(const QString &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 13 },
        }}),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reject'
        QtMocHelpers::SlotData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'exportImages'
        QtMocHelpers::SlotData<int(const QString &, int, int, bool)>(16, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 17 }, { QMetaType::Int, 18 }, { QMetaType::Int, 19 }, { QMetaType::Bool, 20 },
        }}),
        // Slot 'processingFinished'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkExportTiffDialog, qt_meta_tag_ZN3nmc18DkExportTiffDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkExportTiffDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc18DkExportTiffDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc18DkExportTiffDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc18DkExportTiffDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkExportTiffDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkExportTiffDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->updateImage((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1]))); break;
        case 1: _t->updateProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->infoMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->onOpenButtonPressed(); break;
        case 4: _t->onSaveButtonPressed(); break;
        case 5: _t->onFileEditTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->setFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->accept(); break;
        case 8: _t->reject(); break;
        case 9: { int _r = _t->exportImages((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 10: _t->processingFinished(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkExportTiffDialog::*)(const QImage & ) const>(_a, &DkExportTiffDialog::updateImage, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkExportTiffDialog::*)(int ) const>(_a, &DkExportTiffDialog::updateProgress, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkExportTiffDialog::*)(const QString & ) const>(_a, &DkExportTiffDialog::infoMessage, 2))
            return;
    }
}

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

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

int nmc::DkExportTiffDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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::DkExportTiffDialog::updateImage(const QImage & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkExportTiffDialog *>(this), &staticMetaObject, 0, nullptr, _t1);
}

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

// SIGNAL 2
void nmc::DkExportTiffDialog::infoMessage(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkExportTiffDialog *>(this), &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc14DkMosaicDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkMosaicDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc14DkMosaicDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkMosaicDialog",
        "updateImage",
        "",
        "QImage",
        "img",
        "updateProgress",
        "infoMessage",
        "msg",
        "onOpenButtonPressed",
        "onDbButtonPressed",
        "onFileEditTextChanged",
        "filename",
        "onNewWidthBoxValueChanged",
        "i",
        "onNewHeightBoxValueChanged",
        "onNumPatchesVValueChanged",
        "onNumPatchesHValueChanged",
        "onDarkenSliderValueChanged",
        "onLightenSliderValueChanged",
        "onSaturationSliderValueChanged",
        "setFile",
        "file",
        "compute",
        "reject",
        "computeMosaic",
        "filter",
        "suffix",
        "from",
        "to",
        "mosaicFinished",
        "postProcessFinished",
        "buttonClicked",
        "QAbstractButton*",
        "button",
        "updatePatchRes"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'updateImage'
        QtMocHelpers::SignalData<void(const QImage &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'updateProgress'
        QtMocHelpers::SignalData<void(int) const>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'infoMessage'
        QtMocHelpers::SignalData<void(const QString &) const>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'onOpenButtonPressed'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onDbButtonPressed'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onFileEditTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'onNewWidthBoxValueChanged'
        QtMocHelpers::SlotData<void(int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'onNewHeightBoxValueChanged'
        QtMocHelpers::SlotData<void(int)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'onNumPatchesVValueChanged'
        QtMocHelpers::SlotData<void(int)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'onNumPatchesHValueChanged'
        QtMocHelpers::SlotData<void(int)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'onDarkenSliderValueChanged'
        QtMocHelpers::SlotData<void(int)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'onLightenSliderValueChanged'
        QtMocHelpers::SlotData<void(int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'onSaturationSliderValueChanged'
        QtMocHelpers::SlotData<void(int)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'setFile'
        QtMocHelpers::SlotData<void(const QString &)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 21 },
        }}),
        // Slot 'compute'
        QtMocHelpers::SlotData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reject'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'computeMosaic'
        QtMocHelpers::SlotData<int(const QString &, const QString &, int, int)>(24, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 25 }, { QMetaType::QString, 26 }, { QMetaType::Int, 27 }, { QMetaType::Int, 28 },
        }}),
        // Slot 'mosaicFinished'
        QtMocHelpers::SlotData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'postProcessFinished'
        QtMocHelpers::SlotData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'buttonClicked'
        QtMocHelpers::SlotData<void(QAbstractButton *)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 33 },
        }}),
        // Slot 'updatePatchRes'
        QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkMosaicDialog, qt_meta_tag_ZN3nmc14DkMosaicDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkMosaicDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkMosaicDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc14DkMosaicDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc14DkMosaicDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkMosaicDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkMosaicDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->updateImage((*reinterpret_cast<std::add_pointer_t<QImage>>(_a[1]))); break;
        case 1: _t->updateProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->infoMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->onOpenButtonPressed(); break;
        case 4: _t->onDbButtonPressed(); break;
        case 5: _t->onFileEditTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->onNewWidthBoxValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 7: _t->onNewHeightBoxValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->onNumPatchesVValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->onNumPatchesHValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->onDarkenSliderValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->onLightenSliderValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->onSaturationSliderValueChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 13: _t->setFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->compute(); break;
        case 15: _t->reject(); break;
        case 16: { int _r = _t->computeMosaic((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 17: _t->mosaicFinished(); break;
        case 18: _t->postProcessFinished(); break;
        case 19: _t->buttonClicked((*reinterpret_cast<std::add_pointer_t<QAbstractButton*>>(_a[1]))); break;
        case 20: _t->updatePatchRes(); 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< QAbstractButton* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkMosaicDialog::*)(const QImage & ) const>(_a, &DkMosaicDialog::updateImage, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkMosaicDialog::*)(int ) const>(_a, &DkMosaicDialog::updateProgress, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkMosaicDialog::*)(const QString & ) const>(_a, &DkMosaicDialog::infoMessage, 2))
            return;
    }
}

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

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

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

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

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

// SIGNAL 2
void nmc::DkMosaicDialog::infoMessage(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkMosaicDialog *>(this), &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3nmc18DkForceThumbDialogE_t {};
} // unnamed namespace

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

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

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

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

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

int nmc::DkForceThumbDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc15DkWelcomeDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkWelcomeDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkWelcomeDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkWelcomeDialog",
        "accept",
        ""
    };

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

void nmc::DkWelcomeDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkWelcomeDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->accept(); break;
        default: ;
        }
    }
    (void)_a;
}

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

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

int nmc::DkWelcomeDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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_ZN3nmc15DkSvgSizeDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkSvgSizeDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkSvgSizeDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkSvgSizeDialog",
        "onWidthValueChanged",
        "",
        "val",
        "onHeightValueChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onWidthValueChanged'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
        // Slot 'onHeightValueChanged'
        QtMocHelpers::SlotData<void(int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkSvgSizeDialog, qt_meta_tag_ZN3nmc15DkSvgSizeDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkSvgSizeDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkSvgSizeDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkSvgSizeDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc15DkSvgSizeDialogE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkSvgSizeDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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;
}
namespace {
struct qt_meta_tag_ZN3nmc21DkChooseMonitorDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkChooseMonitorDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc21DkChooseMonitorDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkChooseMonitorDialog",
        "exec",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'exec'
        QtMocHelpers::SlotData<int()>(1, 2, QMC::AccessPublic, QMetaType::Int),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkChooseMonitorDialog, qt_meta_tag_ZN3nmc21DkChooseMonitorDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkChooseMonitorDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc21DkChooseMonitorDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc21DkChooseMonitorDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc21DkChooseMonitorDialogE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkChooseMonitorDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 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_ZN3nmc25DkArchiveExtractionDialogE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkArchiveExtractionDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc25DkArchiveExtractionDialogE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkArchiveExtractionDialog",
        "textChanged",
        "",
        "text",
        "checkbocChecked",
        "state",
        "dirTextChanged",
        "loadArchive",
        "filePath",
        "openArchive",
        "openDir",
        "accept"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'textChanged'
        QtMocHelpers::SlotData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'checkbocChecked'
        QtMocHelpers::SlotData<void(int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'dirTextChanged'
        QtMocHelpers::SlotData<void(const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'loadArchive'
        QtMocHelpers::SlotData<void(const QString &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Slot 'loadArchive'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'openArchive'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openDir'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'accept'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkArchiveExtractionDialog, qt_meta_tag_ZN3nmc25DkArchiveExtractionDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkArchiveExtractionDialog::staticMetaObject = { {
    QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc25DkArchiveExtractionDialogE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc25DkArchiveExtractionDialogE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc25DkArchiveExtractionDialogE_t>.metaTypes,
    nullptr
} };

void nmc::DkArchiveExtractionDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkArchiveExtractionDialog *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->textChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->checkbocChecked((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->dirTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->loadArchive((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->loadArchive(); break;
        case 5: _t->openArchive(); break;
        case 6: _t->openDir(); break;
        case 7: _t->accept(); break;
        default: ;
        }
    }
}

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

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

int nmc::DkArchiveExtractionDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDialog::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc15DkDialogManagerE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkDialogManager::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkDialogManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkDialogManager",
        "openShortcutsDialog",
        "",
        "openAppManager",
        "openMosaicDialog",
        "openPrintDialog"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'openShortcutsDialog'
        QtMocHelpers::SlotData<void() const>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openAppManager'
        QtMocHelpers::SlotData<void() const>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openMosaicDialog'
        QtMocHelpers::SlotData<void() const>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openPrintDialog'
        QtMocHelpers::SlotData<void() const>(5, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkDialogManager, qt_meta_tag_ZN3nmc15DkDialogManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkDialogManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkDialogManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkDialogManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc15DkDialogManagerE_t>.metaTypes,
    nullptr
} };

void nmc::DkDialogManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkDialogManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->openShortcutsDialog(); break;
        case 1: _t->openAppManager(); break;
        case 2: _t->openMosaicDialog(); break;
        case 3: _t->openPrintDialog(); break;
        default: ;
        }
    }
    (void)_a;
}

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

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

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