/****************************************************************************
** Meta object code from reading C++ file 'DkNoMacs.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/DkNoMacs.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QSharedPointer>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto nmc::DkNomacsOSXEventFilter::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc22DkNomacsOSXEventFilterE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkNomacsOSXEventFilter",
        "loadFile",
        "",
        "fi"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'loadFile'
        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<DkNomacsOSXEventFilter, qt_meta_tag_ZN3nmc22DkNomacsOSXEventFilterE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkNomacsOSXEventFilter::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc22DkNomacsOSXEventFilterE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc22DkNomacsOSXEventFilterE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc22DkNomacsOSXEventFilterE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto nmc::DkNoMacs::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc8DkNoMacsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkNoMacs",
        "sendArrangeSignal",
        "",
        "overlaid",
        "closeSignal",
        "sendQuitLocalClientsSignal",
        "toggleFullScreen",
        "enterFullScreen",
        "exitFullScreen",
        "toggleDocks",
        "hide",
        "restoreDocks",
        "showExplorer",
        "show",
        "saveSettings",
        "showMetaDataDock",
        "showEditDock",
        "showHistoryDock",
        "showLogDock",
        "showThumbsDock",
        "thumbsDockAreaChanged",
        "openDir",
        "openFile",
        "openQuickLaunch",
        "openFileList",
        "saveFileList",
        "changeSorting",
        "change",
        "goTo",
        "find",
        "filterAction",
        "extractImagesFromArchive",
        "trainFormat",
        "exportTiff",
        "cleanSettings",
        "newInstance",
        "filePath",
        "showMenuBar",
        "openFileWith",
        "QAction*",
        "action",
        "aboutDialog",
        "openDocumentation",
        "bugReport",
        "loadRecursion",
        "setWindowTitle",
        "QSharedPointer<DkImageContainerT>",
        "imgC",
        "QSize",
        "size",
        "edited",
        "attr",
        "showOpacityDialog",
        "opacityUp",
        "opacityDown",
        "changeOpacity",
        "animateChangeOpacity",
        "animateOpacityUp",
        "animateOpacityDown",
        "lockWindow",
        "lock",
        "tcpSetWindowRect",
        "QRect",
        "newRect",
        "opacity",
        "tcpSendWindowRect",
        "tcpSendArrange",
        "newClientConnected",
        "connected",
        "settingsChanged",
        "showUpdaterMessage",
        "msg",
        "title",
        "showUpdateDialog",
        "performUpdate",
        "updateProgress",
        "received",
        "total",
        "updateProgressTranslations",
        "startSetup",
        "updateTranslations",
        "checkForUpdate",
        "silent",
        "startPong",
        "fitFrame",
        "setRecursiveScan",
        "recursive",
        "openPluginManager",
        "clearFileHistory",
        "clearFolderHistory",
        "restartWithTranslationUpdate",
        "restartWithPseudoColor",
        "contrast",
        "restartFrameless",
        "frameless",
        "showRecentFilesOnStartUp",
        "computeThumbsBatch",
        "onWindowLoaded"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'sendArrangeSignal'
        QtMocHelpers::SignalData<void(bool) const>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'closeSignal'
        QtMocHelpers::SignalData<void() const>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sendQuitLocalClientsSignal'
        QtMocHelpers::SignalData<void() const>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleFullScreen'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'enterFullScreen'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'exitFullScreen'
        QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleDocks'
        QtMocHelpers::SlotData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Slot 'restoreDocks'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showExplorer'
        QtMocHelpers::SlotData<void(bool, bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 }, { QMetaType::Bool, 14 },
        }}),
        // Slot 'showExplorer'
        QtMocHelpers::SlotData<void(bool)>(12, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'showMetaDataDock'
        QtMocHelpers::SlotData<void(bool, bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 }, { QMetaType::Bool, 14 },
        }}),
        // Slot 'showMetaDataDock'
        QtMocHelpers::SlotData<void(bool)>(15, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'showEditDock'
        QtMocHelpers::SlotData<void(bool, bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 }, { QMetaType::Bool, 14 },
        }}),
        // Slot 'showEditDock'
        QtMocHelpers::SlotData<void(bool)>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'showHistoryDock'
        QtMocHelpers::SlotData<void(bool, bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 }, { QMetaType::Bool, 14 },
        }}),
        // Slot 'showHistoryDock'
        QtMocHelpers::SlotData<void(bool)>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'showLogDock'
        QtMocHelpers::SlotData<void(bool, bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 }, { QMetaType::Bool, 14 },
        }}),
        // Slot 'showLogDock'
        QtMocHelpers::SlotData<void(bool)>(18, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'showThumbsDock'
        QtMocHelpers::SlotData<void(bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'thumbsDockAreaChanged'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openDir'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openFile'
        QtMocHelpers::SlotData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openQuickLaunch'
        QtMocHelpers::SlotData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openFileList'
        QtMocHelpers::SlotData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'saveFileList'
        QtMocHelpers::SlotData<void()>(25, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'changeSorting'
        QtMocHelpers::SlotData<void(bool)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 27 },
        }}),
        // Slot 'goTo'
        QtMocHelpers::SlotData<void()>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'find'
        QtMocHelpers::SlotData<void(bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 30 },
        }}),
        // Slot 'find'
        QtMocHelpers::SlotData<void()>(29, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'extractImagesFromArchive'
        QtMocHelpers::SlotData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'trainFormat'
        QtMocHelpers::SlotData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'exportTiff'
        QtMocHelpers::SlotData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'cleanSettings'
        QtMocHelpers::SlotData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'newInstance'
        QtMocHelpers::SlotData<void(const QString &)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'newInstance'
        QtMocHelpers::SlotData<void()>(35, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'showMenuBar'
        QtMocHelpers::SlotData<void(bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Slot 'openFileWith'
        QtMocHelpers::SlotData<void(QAction *)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 },
        }}),
        // Slot 'aboutDialog'
        QtMocHelpers::SlotData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openDocumentation'
        QtMocHelpers::SlotData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'bugReport'
        QtMocHelpers::SlotData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loadRecursion'
        QtMocHelpers::SlotData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setWindowTitle'
        QtMocHelpers::SlotData<void(QSharedPointer<DkImageContainerT>)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Slot 'setWindowTitle'
        QtMocHelpers::SlotData<void(const QString &, const QSize &, bool, const QString &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 }, { 0x80000000 | 48, 49 }, { QMetaType::Bool, 50 }, { QMetaType::QString, 51 },
        }}),
        // Slot 'setWindowTitle'
        QtMocHelpers::SlotData<void(const QString &, const QSize &, bool)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 36 }, { 0x80000000 | 48, 49 }, { QMetaType::Bool, 50 },
        }}),
        // Slot 'setWindowTitle'
        QtMocHelpers::SlotData<void(const QString &, const QSize &)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 36 }, { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setWindowTitle'
        QtMocHelpers::SlotData<void(const QString &)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Slot 'showOpacityDialog'
        QtMocHelpers::SlotData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'opacityUp'
        QtMocHelpers::SlotData<void()>(53, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'opacityDown'
        QtMocHelpers::SlotData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'changeOpacity'
        QtMocHelpers::SlotData<void(float)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 27 },
        }}),
        // Slot 'animateChangeOpacity'
        QtMocHelpers::SlotData<void()>(56, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'animateOpacityUp'
        QtMocHelpers::SlotData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'animateOpacityDown'
        QtMocHelpers::SlotData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'lockWindow'
        QtMocHelpers::SlotData<void(bool)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 60 },
        }}),
        // Slot 'tcpSetWindowRect'
        QtMocHelpers::SlotData<void(QRect, bool, bool)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 }, { QMetaType::Bool, 64 }, { QMetaType::Bool, 3 },
        }}),
        // Slot 'tcpSendWindowRect'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'tcpSendArrange'
        QtMocHelpers::SlotData<void()>(66, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'newClientConnected'
        QtMocHelpers::SlotData<void(bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 68 },
        }}),
        // Slot 'settingsChanged'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'showUpdaterMessage'
        QtMocHelpers::SlotData<void(QString, QString)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 71 }, { QMetaType::QString, 72 },
        }}),
        // Slot 'showUpdateDialog'
        QtMocHelpers::SlotData<void(QString, QString)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 71 }, { QMetaType::QString, 72 },
        }}),
        // Slot 'performUpdate'
        QtMocHelpers::SlotData<void()>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateProgress'
        QtMocHelpers::SlotData<void(qint64, qint64)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::LongLong, 76 }, { QMetaType::LongLong, 77 },
        }}),
        // Slot 'updateProgressTranslations'
        QtMocHelpers::SlotData<void(qint64, qint64)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::LongLong, 76 }, { QMetaType::LongLong, 77 },
        }}),
        // Slot 'startSetup'
        QtMocHelpers::SlotData<void(QString)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Slot 'updateTranslations'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkForUpdate'
        QtMocHelpers::SlotData<void(bool)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 82 },
        }}),
        // Slot 'checkForUpdate'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'startPong'
        QtMocHelpers::SlotData<void() const>(83, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'fitFrame'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setRecursiveScan'
        QtMocHelpers::SlotData<void(bool)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 86 },
        }}),
        // Slot 'openPluginManager'
        QtMocHelpers::SlotData<void()>(87, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearFileHistory'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearFolderHistory'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'restartWithTranslationUpdate'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'restartWithPseudoColor'
        QtMocHelpers::SlotData<void(bool)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 92 },
        }}),
        // Slot 'restartFrameless'
        QtMocHelpers::SlotData<void(bool)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 94 },
        }}),
        // Slot 'showRecentFilesOnStartUp'
        QtMocHelpers::SlotData<void()>(95, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'computeThumbsBatch'
        QtMocHelpers::SlotData<void()>(96, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onWindowLoaded'
        QtMocHelpers::SlotData<void()>(97, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DkNoMacs, qt_meta_tag_ZN3nmc8DkNoMacsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject nmc::DkNoMacs::staticMetaObject = { {
    QMetaObject::SuperData::link<QMainWindow::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc8DkNoMacsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3nmc8DkNoMacsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3nmc8DkNoMacsE_t>.metaTypes,
    nullptr
} };

void nmc::DkNoMacs::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DkNoMacs *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->sendArrangeSignal((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->closeSignal(); break;
        case 2: _t->sendQuitLocalClientsSignal(); break;
        case 3: _t->toggleFullScreen(); break;
        case 4: _t->enterFullScreen(); break;
        case 5: _t->exitFullScreen(); break;
        case 6: _t->toggleDocks((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->restoreDocks(); break;
        case 8: _t->showExplorer((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 9: _t->showExplorer((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->showMetaDataDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 11: _t->showMetaDataDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->showEditDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 13: _t->showEditDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->showHistoryDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 15: _t->showHistoryDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->showLogDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 17: _t->showLogDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->showThumbsDock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->thumbsDockAreaChanged(); break;
        case 20: _t->openDir(); break;
        case 21: _t->openFile(); break;
        case 22: _t->openQuickLaunch(); break;
        case 23: _t->openFileList(); break;
        case 24: _t->saveFileList(); break;
        case 25: _t->changeSorting((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 26: _t->goTo(); break;
        case 27: _t->find((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 28: _t->find(); break;
        case 29: _t->extractImagesFromArchive(); break;
        case 30: _t->trainFormat(); break;
        case 31: _t->exportTiff(); break;
        case 32: _t->cleanSettings(); break;
        case 33: _t->newInstance((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 34: _t->newInstance(); break;
        case 35: _t->showMenuBar((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->openFileWith((*reinterpret_cast<std::add_pointer_t<QAction*>>(_a[1]))); break;
        case 37: _t->aboutDialog(); break;
        case 38: _t->openDocumentation(); break;
        case 39: _t->bugReport(); break;
        case 40: _t->loadRecursion(); break;
        case 41: _t->setWindowTitle((*reinterpret_cast<std::add_pointer_t<QSharedPointer<DkImageContainerT>>>(_a[1]))); break;
        case 42: _t->setWindowTitle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 43: _t->setWindowTitle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 44: _t->setWindowTitle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2]))); break;
        case 45: _t->setWindowTitle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 46: _t->showOpacityDialog(); break;
        case 47: _t->opacityUp(); break;
        case 48: _t->opacityDown(); break;
        case 49: _t->changeOpacity((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 50: _t->animateChangeOpacity(); break;
        case 51: _t->animateOpacityUp(); break;
        case 52: _t->animateOpacityDown(); break;
        case 53: _t->lockWindow((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: _t->tcpSetWindowRect((*reinterpret_cast<std::add_pointer_t<QRect>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 55: _t->tcpSendWindowRect(); break;
        case 56: _t->tcpSendArrange(); break;
        case 57: _t->newClientConnected((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 58: _t->settingsChanged(); break;
        case 59: _t->showUpdaterMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 60: _t->showUpdateDialog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 61: _t->performUpdate(); break;
        case 62: _t->updateProgress((*reinterpret_cast<std::add_pointer_t<qint64>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[2]))); break;
        case 63: _t->updateProgressTranslations((*reinterpret_cast<std::add_pointer_t<qint64>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[2]))); break;
        case 64: _t->startSetup((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->updateTranslations(); break;
        case 66: _t->checkForUpdate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 67: _t->checkForUpdate(); break;
        case 68: _t->startPong(); break;
        case 69: _t->fitFrame(); break;
        case 70: _t->setRecursiveScan((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 71: _t->openPluginManager(); break;
        case 72: _t->clearFileHistory(); break;
        case 73: _t->clearFolderHistory(); break;
        case 74: _t->restartWithTranslationUpdate(); break;
        case 75: _t->restartWithPseudoColor((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 76: _t->restartFrameless((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 77: _t->showRecentFilesOnStartUp(); break;
        case 78: _t->computeThumbsBatch(); break;
        case 79: _t->onWindowLoaded(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 36:
            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;
        case 41:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QSharedPointer<DkImageContainerT> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DkNoMacs::*)(bool ) const>(_a, &DkNoMacs::sendArrangeSignal, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkNoMacs::*)() const>(_a, &DkNoMacs::closeSignal, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DkNoMacs::*)() const>(_a, &DkNoMacs::sendQuitLocalClientsSignal, 2))
            return;
    }
}

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

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

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

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

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

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

template <> constexpr inline auto nmc::DkNoMacsSync::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc12DkNoMacsSyncE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkNoMacsSync",
        "startRCServerSignal",
        "",
        "start"
    };

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

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

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

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

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

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

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

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

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

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

int nmc::DkNoMacsIpl::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = DkNoMacsSync::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3nmc17DkNoMacsFramelessE_t {};
} // unnamed namespace

template <> constexpr inline auto nmc::DkNoMacsFrameless::qt_create_metaobjectdata<qt_meta_tag_ZN3nmc17DkNoMacsFramelessE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "nmc::DkNoMacsFrameless",
        "chooseMonitor",
        "",
        "force"
    };

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

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

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

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

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

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

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

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

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

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

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