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

template <> constexpr inline auto nmc::DkBatchContent::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc14DkBatchContentE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchContent",
        "newHeaderText",
        "",
        "txt"
    };

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

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

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

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

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

template <> constexpr inline auto nmc::DkBatchTabButton::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc16DkBatchTabButtonE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchTabButton",
        "infoChanged",
        "",
        "msg",
        "setInfo",
        "info"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'infoChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'setInfo'
        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<DkBatchTabButton, qt_meta_tag_ZN3nmc16DkBatchTabButtonE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchTabButton::staticMetaObject = { {
    QMetaObject::SuperData::link<QPushButton::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkBatchTabButtonE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkBatchTabButtonE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc16DkBatchTabButtonE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto nmc::DkBatchContainer::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc16DkBatchContainerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchContainer",
        "showSignal",
        "",
        "showContent",
        "show"
    };

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

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

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

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

int nmc::DkBatchContainer::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::DkBatchContainer::showSignal()const
{
    QMetaObject::activate(const_cast< nmc::DkBatchContainer *>(this), &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc15DkInputTextEditE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkInputTextEdit::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkInputTextEditE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkInputTextEdit",
        "fileListChangedSignal",
        "",
        "appendFiles",
        "fileList"
    };

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

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

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

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

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

template <> constexpr inline auto nmc::DkBatchInput::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkBatchInputE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchInput",
        "updateDirSignal",
        "",
        "QList<QSharedPointer<DkImageContainerT>>",
        "updateInputDir",
        "changed",
        "setDir",
        "dirPath",
        "browse",
        "updateDir",
        "parameterChanged",
        "selectionChanged",
        "setFileInfo",
        "QFileInfo",
        "file"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'updateDirSignal'
        QtMocHelpers::SignalData<void(QVector<QSharedPointer<DkImageContainerT>>) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'updateInputDir'
        QtMocHelpers::SignalData<void(const QString &) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'changed'
        QtMocHelpers::SignalData<void() const>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setDir'
        QtMocHelpers::SlotData<void(const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Slot 'browse'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateDir'
        QtMocHelpers::SlotData<void(QVector<QSharedPointer<DkImageContainerT>>)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Slot 'parameterChanged'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectionChanged'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFileInfo'
        QtMocHelpers::SlotData<void(QFileInfo)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 14 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchInput, qt_meta_tag_ZN3nmc12DkBatchInputE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchInput::staticMetaObject = { {
    QMetaObject::SuperData::link<DkBatchContent::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkBatchInputE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc12DkBatchInputE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc12DkBatchInputE_t>.metaTypes,
    nullptr
} };

void nmc::DkBatchInput::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkBatchInput *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->updateDirSignal((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<DkImageContainerT>>>>(_a[1]))); break;
        case 1: _t->updateInputDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->changed(); break;
        case 3: _t->setDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->browse(); break;
        case 5: _t->updateDir((*reinterpret_cast<std::add_pointer_t<QList<QSharedPointer<DkImageContainerT>>>>(_a[1]))); break;
        case 6: _t->parameterChanged(); break;
        case 7: _t->selectionChanged(); break;
        case 8: _t->setFileInfo((*reinterpret_cast<std::add_pointer_t<QFileInfo>>(_a[1]))); 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< QList<QSharedPointer<DkImageContainerT>> >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QSharedPointer<DkImageContainerT>> >(); break;
            }
            break;
        case 8:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFileInfo >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkBatchInput::*)(QVector<QSharedPointer<DkImageContainerT>> ) const>(_a, &DkBatchInput::updateDirSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkBatchInput::*)(const QString & ) const>(_a, &DkBatchInput::updateInputDir, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkBatchInput::*)() const>(_a, &DkBatchInput::changed, 2))
            return;
    }
}

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

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

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

// SIGNAL 0
void nmc::DkBatchInput::updateDirSignal(QVector<QSharedPointer<DkImageContainerT>> _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkBatchInput *>(this), &staticMetaObject, 0, nullptr, _t1);
}

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

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

template <> constexpr inline auto nmc::DkFilenameWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc16DkFilenameWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkFilenameWidget",
        "plusPressed",
        "",
        "DkFilenameWidget*",
        "minusPressed",
        "changed",
        "typeCBChanged",
        "index",
        "pbPlusPressed",
        "pbMinusPressed",
        "checkForUserInput",
        "digitCBChanged"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'plusPressed'
        QtMocHelpers::SignalData<void(DkFilenameWidget *) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'minusPressed'
        QtMocHelpers::SignalData<void(DkFilenameWidget *) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'changed'
        QtMocHelpers::SignalData<void() const>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'typeCBChanged'
        QtMocHelpers::SlotData<void(int)>(6, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 7 },
        }}),
        // Slot 'pbPlusPressed'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'pbMinusPressed'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'checkForUserInput'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'digitCBChanged'
        QtMocHelpers::SlotData<void(int)>(11, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 7 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkFilenameWidget, qt_meta_tag_ZN3nmc16DkFilenameWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkFilenameWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkFilenameWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc16DkFilenameWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc16DkFilenameWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkFilenameWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkFilenameWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->plusPressed((*reinterpret_cast<std::add_pointer_t<DkFilenameWidget*>>(_a[1]))); break;
        case 1: _t->minusPressed((*reinterpret_cast<std::add_pointer_t<DkFilenameWidget*>>(_a[1]))); break;
        case 2: _t->changed(); break;
        case 3: _t->typeCBChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->pbPlusPressed(); break;
        case 5: _t->pbMinusPressed(); break;
        case 6: _t->checkForUserInput(); break;
        case 7: _t->digitCBChanged((*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 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DkFilenameWidget* >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DkFilenameWidget* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkFilenameWidget::*)(DkFilenameWidget * ) const>(_a, &DkFilenameWidget::plusPressed, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkFilenameWidget::*)(DkFilenameWidget * ) const>(_a, &DkFilenameWidget::minusPressed, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkFilenameWidget::*)() const>(_a, &DkFilenameWidget::changed, 2))
            return;
    }
}

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

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

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

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

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

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

template <> constexpr inline auto nmc::DkBatchOutput::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkBatchOutputE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchOutput",
        "changed",
        "",
        "setInputDir",
        "dirPath",
        "browse",
        "plusPressed",
        "DkFilenameWidget*",
        "widget",
        "tag",
        "minusPressed",
        "extensionCBChanged",
        "index",
        "parameterChanged",
        "updateFileLabelPreview",
        "useInputFolderChanged",
        "checked",
        "setDir",
        "updateLineEdit"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'changed'
        QtMocHelpers::SignalData<void() const>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setInputDir'
        QtMocHelpers::SlotData<void(const QString &)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'browse'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'plusPressed'
        QtMocHelpers::SlotData<void(DkFilenameWidget *, const QString &)>(6, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 7, 8 }, { QMetaType::QString, 9 },
        }}),
        // Slot 'plusPressed'
        QtMocHelpers::SlotData<void(DkFilenameWidget *)>(6, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Slot 'minusPressed'
        QtMocHelpers::SlotData<void(DkFilenameWidget *)>(10, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Slot 'extensionCBChanged'
        QtMocHelpers::SlotData<void(int)>(11, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 12 },
        }}),
        // Slot 'parameterChanged'
        QtMocHelpers::SlotData<void()>(13, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateFileLabelPreview'
        QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'useInputFolderChanged'
        QtMocHelpers::SlotData<void(bool)>(15, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 16 },
        }}),
        // Slot 'setDir'
        QtMocHelpers::SlotData<void(const QString &, bool)>(17, 2, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 4 }, { QMetaType::Bool, 18 },
        }}),
        // Slot 'setDir'
        QtMocHelpers::SlotData<void(const QString &)>(17, 2, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchOutput, qt_meta_tag_ZN3nmc13DkBatchOutputE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchOutput::staticMetaObject = { {
    QMetaObject::SuperData::link<DkBatchContent::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkBatchOutputE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkBatchOutputE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkBatchOutputE_t>.metaTypes,
    nullptr
} };

void nmc::DkBatchOutput::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkBatchOutput *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->changed(); break;
        case 1: _t->setInputDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->browse(); break;
        case 3: _t->plusPressed((*reinterpret_cast<std::add_pointer_t<DkFilenameWidget*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 4: _t->plusPressed((*reinterpret_cast<std::add_pointer_t<DkFilenameWidget*>>(_a[1]))); break;
        case 5: _t->minusPressed((*reinterpret_cast<std::add_pointer_t<DkFilenameWidget*>>(_a[1]))); break;
        case 6: _t->extensionCBChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 7: _t->parameterChanged(); break;
        case 8: _t->updateFileLabelPreview(); break;
        case 9: _t->useInputFolderChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->setDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 11: _t->setDir((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DkFilenameWidget* >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DkFilenameWidget* >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DkFilenameWidget* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkBatchOutput::*)() const>(_a, &DkBatchOutput::changed, 0))
            return;
    }
}

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

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

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

// SIGNAL 0
void nmc::DkBatchOutput::changed()const
{
    QMetaObject::activate(const_cast< nmc::DkBatchOutput *>(this), &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3nmc22DkProfileSummaryWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkProfileSummaryWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc22DkProfileSummaryWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkProfileSummaryWidget",
        "deleteCurrentProfile",
        "",
        "updateCurrentProfile",
        "exportCurrentProfile",
        "onDeleteButtonClicked",
        "onUpdateButtonClicked",
        "onExportButtonClicked"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'deleteCurrentProfile'
        QtMocHelpers::SignalData<void() const>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateCurrentProfile'
        QtMocHelpers::SignalData<void() const>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'exportCurrentProfile'
        QtMocHelpers::SignalData<void() const>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onDeleteButtonClicked'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onUpdateButtonClicked'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onExportButtonClicked'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkProfileSummaryWidget, qt_meta_tag_ZN3nmc22DkProfileSummaryWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkProfileSummaryWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc22DkProfileSummaryWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc22DkProfileSummaryWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc22DkProfileSummaryWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkProfileSummaryWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkProfileSummaryWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->deleteCurrentProfile(); break;
        case 1: _t->updateCurrentProfile(); break;
        case 2: _t->exportCurrentProfile(); break;
        case 3: _t->onDeleteButtonClicked(); break;
        case 4: _t->onUpdateButtonClicked(); break;
        case 5: _t->onExportButtonClicked(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkProfileSummaryWidget::*)() const>(_a, &DkProfileSummaryWidget::deleteCurrentProfile, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkProfileSummaryWidget::*)() const>(_a, &DkProfileSummaryWidget::updateCurrentProfile, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkProfileSummaryWidget::*)() const>(_a, &DkProfileSummaryWidget::exportCurrentProfile, 2))
            return;
    }
}

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

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

int nmc::DkProfileSummaryWidget::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 < 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::DkProfileSummaryWidget::deleteCurrentProfile()const
{
    QMetaObject::activate(const_cast< nmc::DkProfileSummaryWidget *>(this), &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void nmc::DkProfileSummaryWidget::updateCurrentProfile()const
{
    QMetaObject::activate(const_cast< nmc::DkProfileSummaryWidget *>(this), &staticMetaObject, 1, nullptr);
}

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

template <> constexpr inline auto nmc::DkProfileWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc15DkProfileWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkProfileWidget",
        "loadProfileSignal",
        "",
        "profilePath",
        "saveProfileSignal",
        "applyDefaultSignal",
        "onProfileListItemSelectionChanged",
        "onSaveButtonClicked",
        "onResetButtonClicked",
        "updateCurrentProfile",
        "deleteCurrentProfile",
        "exportCurrentProfile"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadProfileSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'saveProfileSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'applyDefaultSignal'
        QtMocHelpers::SignalData<void() const>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onProfileListItemSelectionChanged'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onSaveButtonClicked'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onResetButtonClicked'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateCurrentProfile'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'deleteCurrentProfile'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'exportCurrentProfile'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkProfileWidget, qt_meta_tag_ZN3nmc15DkProfileWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkProfileWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkBatchContent::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkProfileWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc15DkProfileWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc15DkProfileWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkProfileWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkProfileWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->loadProfileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->saveProfileSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->applyDefaultSignal(); break;
        case 3: _t->onProfileListItemSelectionChanged(); break;
        case 4: _t->onSaveButtonClicked(); break;
        case 5: _t->onResetButtonClicked(); break;
        case 6: _t->updateCurrentProfile(); break;
        case 7: _t->deleteCurrentProfile(); break;
        case 8: _t->exportCurrentProfile(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkProfileWidget::*)(const QString & ) const>(_a, &DkProfileWidget::loadProfileSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkProfileWidget::*)(const QString & ) const>(_a, &DkProfileWidget::saveProfileSignal, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkProfileWidget::*)() const>(_a, &DkProfileWidget::applyDefaultSignal, 2))
            return;
    }
}

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

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

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

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

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

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

template <> constexpr inline auto nmc::DkBatchPluginWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc19DkBatchPluginWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchPluginWidget",
        "itemChanged",
        "",
        "QStandardItem*",
        "item",
        "selectionChanged",
        "QItemSelection",
        "selected",
        "changeSetting",
        "key",
        "QVariant",
        "value",
        "parentList",
        "removeSetting",
        "updateHeader"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'itemChanged'
        QtMocHelpers::SlotData<void(QStandardItem *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'selectionChanged'
        QtMocHelpers::SlotData<void(const QItemSelection &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'changeSetting'
        QtMocHelpers::SlotData<void(const QString &, const QVariant &, const QStringList &) const>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 }, { 0x80000000 | 10, 11 }, { QMetaType::QStringList, 12 },
        }}),
        // Slot 'removeSetting'
        QtMocHelpers::SlotData<void(const QString &, const QStringList &) const>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 }, { QMetaType::QStringList, 12 },
        }}),
        // Slot 'updateHeader'
        QtMocHelpers::SlotData<void() const>(14, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchPluginWidget, qt_meta_tag_ZN3nmc19DkBatchPluginWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchPluginWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkBatchContent::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkBatchPluginWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc19DkBatchPluginWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc19DkBatchPluginWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkBatchPluginWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkBatchPluginWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->itemChanged((*reinterpret_cast<std::add_pointer_t<QStandardItem*>>(_a[1]))); break;
        case 1: _t->selectionChanged((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1]))); break;
        case 2: _t->changeSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3]))); break;
        case 3: _t->removeSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2]))); break;
        case 4: _t->updateHeader(); break;
        default: ;
        }
    }
}

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

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

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

template <> constexpr inline auto nmc::DkBatchManipulatorWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc24DkBatchManipulatorWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchManipulatorWidget",
        "itemChanged",
        "",
        "QStandardItem*",
        "item",
        "selectionChanged",
        "QItemSelection",
        "selected",
        "renderPreview",
        "QSharedPointer<DkBaseManipulator>",
        "mpl",
        "selectManipulator",
        "updateHeader"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'itemChanged'
        QtMocHelpers::SlotData<void(QStandardItem *)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'selectionChanged'
        QtMocHelpers::SlotData<void(const QItemSelection &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'renderPreview'
        QtMocHelpers::SlotData<void(QSharedPointer<DkBaseManipulator>)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'selectManipulator'
        QtMocHelpers::SlotData<void(QSharedPointer<DkBaseManipulator>)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'selectManipulator'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateHeader'
        QtMocHelpers::SlotData<void() const>(12, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchManipulatorWidget, qt_meta_tag_ZN3nmc24DkBatchManipulatorWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchManipulatorWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkBatchContent::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc24DkBatchManipulatorWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc24DkBatchManipulatorWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc24DkBatchManipulatorWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkBatchManipulatorWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkBatchManipulatorWidget *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->itemChanged((*reinterpret_cast<std::add_pointer_t<QStandardItem*>>(_a[1]))); break;
        case 1: _t->selectionChanged((*reinterpret_cast<std::add_pointer_t<QItemSelection>>(_a[1]))); break;
        case 2: _t->renderPreview((*reinterpret_cast<std::add_pointer_t<QSharedPointer<DkBaseManipulator>>>(_a[1]))); break;
        case 3: _t->selectManipulator((*reinterpret_cast<std::add_pointer_t<QSharedPointer<DkBaseManipulator>>>(_a[1]))); break;
        case 4: _t->selectManipulator(); break;
        case 5: _t->updateHeader(); break;
        default: ;
        }
    }
}

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

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

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

template <> constexpr inline auto nmc::DkBatchTransformWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc22DkBatchTransformWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchTransformWidget",
        "updateHeader",
        "",
        "modeChanged"
    };

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

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

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

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

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

template <> constexpr inline auto nmc::DkBatchButtonsWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc20DkBatchButtonsWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchButtonsWidget",
        "playSignal",
        "",
        "play",
        "showLogSignal"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'playSignal'
        QtMocHelpers::SignalData<void(bool) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'playSignal'
        QtMocHelpers::SignalData<void() const>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Signal 'showLogSignal'
        QtMocHelpers::SignalData<void() const>(4, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchButtonsWidget, qt_meta_tag_ZN3nmc20DkBatchButtonsWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchButtonsWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc20DkBatchButtonsWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc20DkBatchButtonsWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc20DkBatchButtonsWidgetE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkBatchButtonsWidget::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::DkBatchButtonsWidget::playSignal(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkBatchButtonsWidget *>(this), &staticMetaObject, 0, nullptr, _t1);
}

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

template <> constexpr inline auto nmc::DkBatchInfoWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc17DkBatchInfoWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchInfoWidget",
        "setInfo",
        "",
        "message",
        "DkBatchInfoWidget::InfoMode",
        "mode"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'setInfo'
        QtMocHelpers::SlotData<void(const QString &, const DkBatchInfoWidget::InfoMode &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { 0x80000000 | 4, 5 },
        }}),
        // Slot 'setInfo'
        QtMocHelpers::SlotData<void(const QString &)>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchInfoWidget, qt_meta_tag_ZN3nmc17DkBatchInfoWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchInfoWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkFadeWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkBatchInfoWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc17DkBatchInfoWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc17DkBatchInfoWidgetE_t>.metaTypes,
    nullptr
} };

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

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

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

int nmc::DkBatchInfoWidget::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 < 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_ZN3nmc13DkBatchWidgetE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkBatchWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc13DkBatchWidgetE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkBatchWidget",
        "infoSignal",
        "",
        "message",
        "DkBatchInfoWidget::InfoMode",
        "mode",
        "toggleBatch",
        "start",
        "widgetChanged",
        "showLog",
        "processingFinished",
        "updateProgress",
        "progress",
        "updateLog",
        "setSelectedFiles",
        "selFiles",
        "changeWidget",
        "DkBatchContainer*",
        "widget",
        "nextTab",
        "previousTab",
        "saveProfile",
        "profilePath",
        "loadProfile",
        "applyDefault"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'infoSignal'
        QtMocHelpers::SignalData<void(const QString &, const DkBatchInfoWidget::InfoMode &) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { 0x80000000 | 4, 5 },
        }}),
        // Signal 'infoSignal'
        QtMocHelpers::SignalData<void(const QString &) const>(1, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'toggleBatch'
        QtMocHelpers::SlotData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'widgetChanged'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showLog'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'processingFinished'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateProgress'
        QtMocHelpers::SlotData<void(int)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 12 },
        }}),
        // Slot 'updateLog'
        QtMocHelpers::SlotData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setSelectedFiles'
        QtMocHelpers::SlotData<void(const QStringList &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 15 },
        }}),
        // Slot 'changeWidget'
        QtMocHelpers::SlotData<void(DkBatchContainer *)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 18 },
        }}),
        // Slot 'changeWidget'
        QtMocHelpers::SlotData<void()>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'nextTab'
        QtMocHelpers::SlotData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'previousTab'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'saveProfile'
        QtMocHelpers::SlotData<void(const QString &) const>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 22 },
        }}),
        // Slot 'loadProfile'
        QtMocHelpers::SlotData<void(const QString &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 22 },
        }}),
        // Slot 'applyDefault'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkBatchWidget, qt_meta_tag_ZN3nmc13DkBatchWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkBatchWidget::staticMetaObject = { {
    QMetaObject::SuperData::link<DkWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkBatchWidgetE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc13DkBatchWidgetE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc13DkBatchWidgetE_t>.metaTypes,
    nullptr
} };

void nmc::DkBatchWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkBatchWidget *>(_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<DkBatchInfoWidget::InfoMode>>(_a[2]))); break;
        case 1: _t->infoSignal((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->toggleBatch((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->widgetChanged(); break;
        case 4: _t->showLog(); break;
        case 5: _t->processingFinished(); break;
        case 6: _t->updateProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 7: _t->updateLog(); break;
        case 8: _t->setSelectedFiles((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 9: _t->changeWidget((*reinterpret_cast<std::add_pointer_t<DkBatchContainer*>>(_a[1]))); break;
        case 10: _t->changeWidget(); break;
        case 11: _t->nextTab(); break;
        case 12: _t->previousTab(); break;
        case 13: _t->saveProfile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->loadProfile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 15: _t->applyDefault(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DkBatchContainer* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkBatchWidget::*)(const QString & , const DkBatchInfoWidget::InfoMode & ) const>(_a, &DkBatchWidget::infoSignal, 0))
            return;
    }
}

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

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

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

// SIGNAL 0
void nmc::DkBatchWidget::infoSignal(const QString & _t1, const DkBatchInfoWidget::InfoMode & _t2)const
{
    QMetaObject::activate<void>(const_cast< nmc::DkBatchWidget *>(this), &staticMetaObject, 0, nullptr, _t1, _t2);
}
QT_WARNING_POP
