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

#include "../../../../kstars-3.8.4.1/kstars/ekos/scheduler/schedulerprocess.h"
#include <QtNetwork/QSslError>
#include <QtDataVisualization/qbar3dseries.h>
#include <QtDataVisualization/q3dscene.h>
#include <QtGui/qtextcursor.h>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto Ekos::SchedulerProcess::qt_create_metaobjectdata<qt_meta_tag_ZN4Ekos16SchedulerProcessE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Ekos::SchedulerProcess",
        "D-Bus Interface",
        "org.kde.kstars.Ekos.Scheduler",
        "newLog",
        "",
        "text",
        "newStatus",
        "SchedulerState",
        "state",
        "newWeatherStatus",
        "ISD::Weather::Status",
        "schedulerStopped",
        "shutdownStarted",
        "schedulerSleeping",
        "shutdown",
        "sleep",
        "schedulerPaused",
        "changeSleepLabel",
        "show",
        "jobsUpdated",
        "QJsonArray",
        "jobsList",
        "updateJobTable",
        "SchedulerJob*",
        "job",
        "clearJobTable",
        "changeCurrentSequence",
        "sequenceFileURL",
        "interfaceReady",
        "QDBusInterface*",
        "iface",
        "addJob",
        "syncGreedyParams",
        "syncGUIToGeneralSettings",
        "updateSchedulerURL",
        "fileURL",
        "targetDistance",
        "distance",
        "jobStarted",
        "jobName",
        "jobEnded",
        "endReason",
        "setINDICommunicationStatus",
        "Ekos::CommunicationStatus",
        "status",
        "setEkosCommunicationStatus",
        "startShutdownDueToWeather",
        "syncProperties",
        "checkAlignment",
        "QVariantMap",
        "metadata",
        "trainname",
        "solverDone",
        "timedOut",
        "success",
        "FITSImage::Solution",
        "solution",
        "elapsedSeconds",
        "queueExecutionCompleted",
        "queueItemFailed",
        "QueueItem*",
        "item",
        "error",
        "checkInterfaceReady",
        "registerNewModule",
        "name",
        "registerNewDevice",
        "interface",
        "setAlignStatus",
        "Ekos::AlignState",
        "setGuideStatus",
        "Ekos::GuideState",
        "setCaptureStatus",
        "Ekos::CaptureState",
        "setFocusStatus",
        "Ekos::FocusState",
        "setMountStatus",
        "ISD::Mount::Status",
        "setSafetyStatus",
        "IPState",
        "setWeatherStatus",
        "fromStandaloneSafetyMonitor",
        "execute",
        "stopCurrentJobAction",
        "wakeUpScheduler",
        "start",
        "Q_NOREPLY",
        "stop",
        "removeAllJobs",
        "loadScheduler",
        "setSequence",
        "resetAllJobs",
        "startSlew",
        "startFocusing",
        "startAstrometry",
        "startGuiding",
        "resetCalibration",
        "stopGuiding",
        "startCapture",
        "restart",
        "completeShutdown",
        "disconnectINDI",
        "checkParkWaitState",
        "setPaused",
        "resetJobs",
        "startJobEvaluation",
        "evaluateJobs",
        "evaluateOnly",
        "saveScheduler",
        "QUrl",
        "appendEkosScheduleList",
        "appendLogText",
        "logentry",
        "clearLog",
        "isMountParked",
        "isDomeParked",
        "Ekos::SchedulerState",
        "profile",
        "currentJobName",
        "currentJobJson",
        "jsonJobs",
        "logText"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'newLog'
        QtMocHelpers::SignalData<void(const QString &)>(3, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'newStatus'
        QtMocHelpers::SignalData<void(SchedulerState)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Signal 'newWeatherStatus'
        QtMocHelpers::SignalData<void(ISD::Weather::Status)>(9, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 8 },
        }}),
        // Signal 'schedulerStopped'
        QtMocHelpers::SignalData<void()>(11, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shutdownStarted'
        QtMocHelpers::SignalData<void()>(12, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'schedulerSleeping'
        QtMocHelpers::SignalData<void(bool, bool)>(13, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 14 }, { QMetaType::Bool, 15 },
        }}),
        // Signal 'schedulerPaused'
        QtMocHelpers::SignalData<void()>(16, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'changeSleepLabel'
        QtMocHelpers::SignalData<void(QString, bool)>(17, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 }, { QMetaType::Bool, 18 },
        }}),
        // Signal 'changeSleepLabel'
        QtMocHelpers::SignalData<void(QString)>(17, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'jobsUpdated'
        QtMocHelpers::SignalData<void(QJsonArray)>(19, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 21 },
        }}),
        // Signal 'updateJobTable'
        QtMocHelpers::SignalData<void(SchedulerJob *)>(22, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 24 },
        }}),
        // Signal 'updateJobTable'
        QtMocHelpers::SignalData<void()>(22, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Signal 'clearJobTable'
        QtMocHelpers::SignalData<void()>(25, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'changeCurrentSequence'
        QtMocHelpers::SignalData<void(const QString &)>(26, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 27 },
        }}),
        // Signal 'interfaceReady'
        QtMocHelpers::SignalData<void(QDBusInterface *)>(28, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 29, 30 },
        }}),
        // Signal 'addJob'
        QtMocHelpers::SignalData<void(SchedulerJob *)>(31, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 24 },
        }}),
        // Signal 'syncGreedyParams'
        QtMocHelpers::SignalData<void()>(32, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'syncGUIToGeneralSettings'
        QtMocHelpers::SignalData<void()>(33, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateSchedulerURL'
        QtMocHelpers::SignalData<void(const QString &)>(34, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Signal 'targetDistance'
        QtMocHelpers::SignalData<void(double)>(36, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 37 },
        }}),
        // Signal 'jobStarted'
        QtMocHelpers::SignalData<void(const QString &)>(38, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'jobEnded'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(40, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 }, { QMetaType::QString, 41 },
        }}),
        // Slot 'setINDICommunicationStatus'
        QtMocHelpers::SlotData<void(Ekos::CommunicationStatus)>(42, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Slot 'setEkosCommunicationStatus'
        QtMocHelpers::SlotData<void(Ekos::CommunicationStatus)>(45, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Slot 'startShutdownDueToWeather'
        QtMocHelpers::SlotData<void()>(46, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'syncProperties'
        QtMocHelpers::SlotData<void()>(47, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'checkAlignment'
        QtMocHelpers::SlotData<void(const QVariantMap &, const QString &)>(48, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 49, 50 }, { QMetaType::QString, 51 },
        }}),
        // Slot 'solverDone'
        QtMocHelpers::SlotData<void(bool, bool, const FITSImage::Solution &, double)>(52, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 53 }, { QMetaType::Bool, 54 }, { 0x80000000 | 55, 56 }, { QMetaType::Double, 57 },
        }}),
        // Slot 'queueExecutionCompleted'
        QtMocHelpers::SlotData<void()>(58, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'queueItemFailed'
        QtMocHelpers::SlotData<void(QueueItem *, const QString &)>(59, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 60, 61 }, { QMetaType::QString, 62 },
        }}),
        // Slot 'checkInterfaceReady'
        QtMocHelpers::SlotData<void(QDBusInterface *)>(63, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 29, 30 },
        }}),
        // Slot 'registerNewModule'
        QtMocHelpers::SlotData<void(const QString &)>(64, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 65 },
        }}),
        // Slot 'registerNewDevice'
        QtMocHelpers::SlotData<void(const QString &, int)>(66, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 65 }, { QMetaType::Int, 67 },
        }}),
        // Slot 'setAlignStatus'
        QtMocHelpers::SlotData<void(Ekos::AlignState)>(68, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 69, 44 },
        }}),
        // Slot 'setGuideStatus'
        QtMocHelpers::SlotData<void(Ekos::GuideState)>(70, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 71, 44 },
        }}),
        // Slot 'setCaptureStatus'
        QtMocHelpers::SlotData<void(Ekos::CaptureState, const QString &)>(72, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 73, 44 }, { QMetaType::QString, 51 },
        }}),
        // Slot 'setFocusStatus'
        QtMocHelpers::SlotData<void(Ekos::FocusState, const QString &)>(74, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 75, 44 }, { QMetaType::QString, 51 },
        }}),
        // Slot 'setMountStatus'
        QtMocHelpers::SlotData<void(ISD::Mount::Status)>(76, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 77, 44 },
        }}),
        // Slot 'setSafetyStatus'
        QtMocHelpers::SlotData<void(IPState)>(78, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 79, 44 },
        }}),
        // Slot 'setWeatherStatus'
        QtMocHelpers::SlotData<void(ISD::Weather::Status, bool)>(80, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 10, 44 }, { QMetaType::Bool, 81 },
        }}),
        // Slot 'setWeatherStatus'
        QtMocHelpers::SlotData<void(ISD::Weather::Status)>(80, 4, QMC::AccessPrivate | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 10, 44 },
        }}),
        // Method 'execute'
        QtMocHelpers::MethodData<void()>(82, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'stopCurrentJobAction'
        QtMocHelpers::MethodData<void()>(83, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'wakeUpScheduler'
        QtMocHelpers::MethodData<void()>(84, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'start'
        QtMocHelpers::MethodData<void()>(85, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'stop'
        QtMocHelpers::MethodData<void()>(87, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'removeAllJobs'
        QtMocHelpers::MethodData<void()>(88, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'loadScheduler'
        QtMocHelpers::MethodData<bool(const QString &)>(89, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::QString, 35 },
        }}),
        // Method 'setSequence'
        QtMocHelpers::MethodData<void(const QString &)>(90, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 27 },
        }}),
        // Method 'resetAllJobs'
        QtMocHelpers::MethodData<void()>(91, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'startSlew'
        QtMocHelpers::MethodData<void()>(92, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'startFocusing'
        QtMocHelpers::MethodData<void()>(93, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'startAstrometry'
        QtMocHelpers::MethodData<void()>(94, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'startGuiding'
        QtMocHelpers::MethodData<void(bool)>(95, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 96 },
        }}),
        // Method 'startGuiding'
        QtMocHelpers::MethodData<void()>(95, 86, QMC::AccessPublic | QMC::MethodCloned | QMC::MethodScriptable, QMetaType::Void),
        // Method 'stopGuiding'
        QtMocHelpers::MethodData<void()>(97, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'startCapture'
        QtMocHelpers::MethodData<void(bool)>(98, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 99 },
        }}),
        // Method 'startCapture'
        QtMocHelpers::MethodData<void()>(98, 86, QMC::AccessPublic | QMC::MethodCloned | QMC::MethodScriptable, QMetaType::Void),
        // Method 'completeShutdown'
        QtMocHelpers::MethodData<bool()>(100, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Method 'disconnectINDI'
        QtMocHelpers::MethodData<void()>(101, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'checkParkWaitState'
        QtMocHelpers::MethodData<bool()>(102, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Method 'setPaused'
        QtMocHelpers::MethodData<void()>(103, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'resetJobs'
        QtMocHelpers::MethodData<void()>(104, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'startJobEvaluation'
        QtMocHelpers::MethodData<void()>(105, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'evaluateJobs'
        QtMocHelpers::MethodData<void(bool)>(106, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 107 },
        }}),
        // Method 'saveScheduler'
        QtMocHelpers::MethodData<bool(const QUrl &)>(108, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { 0x80000000 | 109, 35 },
        }}),
        // Method 'appendEkosScheduleList'
        QtMocHelpers::MethodData<bool(const QString &)>(110, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::QString, 35 },
        }}),
        // Method 'appendLogText'
        QtMocHelpers::MethodData<void(const QString &)>(111, 86, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 112 },
        }}),
        // Method 'clearLog'
        QtMocHelpers::MethodData<void()>(113, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Method 'isMountParked'
        QtMocHelpers::MethodData<bool()>(114, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Method 'isDomeParked'
        QtMocHelpers::MethodData<bool()>(115, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'status'
        QtMocHelpers::PropertyData<Ekos::SchedulerState>(44, 0x80000000 | 116, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'profile'
        QtMocHelpers::PropertyData<QString>(117, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'currentJobName'
        QtMocHelpers::PropertyData<QString>(118, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'currentJobJson'
        QtMocHelpers::PropertyData<QString>(119, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'jsonJobs'
        QtMocHelpers::PropertyData<QString>(120, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'logText'
        QtMocHelpers::PropertyData<QStringList>(121, QMetaType::QStringList, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<SchedulerProcess, qt_meta_tag_ZN4Ekos16SchedulerProcessE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Ekos::SchedulerProcess::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Ekos16SchedulerProcessE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Ekos16SchedulerProcessE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4Ekos16SchedulerProcessE_t>.metaTypes,
    nullptr
} };

void Ekos::SchedulerProcess::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SchedulerProcess *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->newLog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->newStatus((*reinterpret_cast<std::add_pointer_t<SchedulerState>>(_a[1]))); break;
        case 2: _t->newWeatherStatus((*reinterpret_cast<std::add_pointer_t<ISD::Weather::Status>>(_a[1]))); break;
        case 3: _t->schedulerStopped(); break;
        case 4: _t->shutdownStarted(); break;
        case 5: _t->schedulerSleeping((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 6: _t->schedulerPaused(); break;
        case 7: _t->changeSleepLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 8: _t->changeSleepLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 9: _t->jobsUpdated((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1]))); break;
        case 10: _t->updateJobTable((*reinterpret_cast<std::add_pointer_t<SchedulerJob*>>(_a[1]))); break;
        case 11: _t->updateJobTable(); break;
        case 12: _t->clearJobTable(); break;
        case 13: _t->changeCurrentSequence((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->interfaceReady((*reinterpret_cast<std::add_pointer_t<QDBusInterface*>>(_a[1]))); break;
        case 15: _t->addJob((*reinterpret_cast<std::add_pointer_t<SchedulerJob*>>(_a[1]))); break;
        case 16: _t->syncGreedyParams(); break;
        case 17: _t->syncGUIToGeneralSettings(); break;
        case 18: _t->updateSchedulerURL((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->targetDistance((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 20: _t->jobStarted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 21: _t->jobEnded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 22: _t->setINDICommunicationStatus((*reinterpret_cast<std::add_pointer_t<Ekos::CommunicationStatus>>(_a[1]))); break;
        case 23: _t->setEkosCommunicationStatus((*reinterpret_cast<std::add_pointer_t<Ekos::CommunicationStatus>>(_a[1]))); break;
        case 24: _t->startShutdownDueToWeather(); break;
        case 25: _t->syncProperties(); break;
        case 26: _t->checkAlignment((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 27: _t->solverDone((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<FITSImage::Solution>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[4]))); break;
        case 28: _t->queueExecutionCompleted(); break;
        case 29: _t->queueItemFailed((*reinterpret_cast<std::add_pointer_t<QueueItem*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 30: _t->checkInterfaceReady((*reinterpret_cast<std::add_pointer_t<QDBusInterface*>>(_a[1]))); break;
        case 31: _t->registerNewModule((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 32: _t->registerNewDevice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 33: _t->setAlignStatus((*reinterpret_cast<std::add_pointer_t<Ekos::AlignState>>(_a[1]))); break;
        case 34: _t->setGuideStatus((*reinterpret_cast<std::add_pointer_t<Ekos::GuideState>>(_a[1]))); break;
        case 35: _t->setCaptureStatus((*reinterpret_cast<std::add_pointer_t<Ekos::CaptureState>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 36: _t->setFocusStatus((*reinterpret_cast<std::add_pointer_t<Ekos::FocusState>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 37: _t->setMountStatus((*reinterpret_cast<std::add_pointer_t<ISD::Mount::Status>>(_a[1]))); break;
        case 38: _t->setSafetyStatus((*reinterpret_cast<std::add_pointer_t<IPState>>(_a[1]))); break;
        case 39: _t->setWeatherStatus((*reinterpret_cast<std::add_pointer_t<ISD::Weather::Status>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 40: _t->setWeatherStatus((*reinterpret_cast<std::add_pointer_t<ISD::Weather::Status>>(_a[1]))); break;
        case 41: _t->execute(); break;
        case 42: _t->stopCurrentJobAction(); break;
        case 43: _t->wakeUpScheduler(); break;
        case 44: _t->start(); break;
        case 45: _t->stop(); break;
        case 46: _t->removeAllJobs(); break;
        case 47: { bool _r = _t->loadScheduler((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 48: _t->setSequence((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 49: _t->resetAllJobs(); break;
        case 50: _t->startSlew(); break;
        case 51: _t->startFocusing(); break;
        case 52: _t->startAstrometry(); break;
        case 53: _t->startGuiding((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: _t->startGuiding(); break;
        case 55: _t->stopGuiding(); break;
        case 56: _t->startCapture((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 57: _t->startCapture(); break;
        case 58: { bool _r = _t->completeShutdown();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 59: _t->disconnectINDI(); break;
        case 60: { bool _r = _t->checkParkWaitState();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 61: _t->setPaused(); break;
        case 62: _t->resetJobs(); break;
        case 63: _t->startJobEvaluation(); break;
        case 64: _t->evaluateJobs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 65: { bool _r = _t->saveScheduler((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 66: { bool _r = _t->appendEkosScheduleList((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 67: _t->appendLogText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 68: _t->clearLog(); break;
        case 69: { bool _r = _t->isMountParked();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: { bool _r = _t->isDomeParked();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ISD::Weather::Status >(); break;
            }
            break;
        case 22:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::CommunicationStatus >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::CommunicationStatus >(); break;
            }
            break;
        case 33:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::AlignState >(); break;
            }
            break;
        case 34:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::GuideState >(); break;
            }
            break;
        case 35:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::CaptureState >(); break;
            }
            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< Ekos::FocusState >(); break;
            }
            break;
        case 37:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ISD::Mount::Status >(); break;
            }
            break;
        case 39:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ISD::Weather::Status >(); break;
            }
            break;
        case 40:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ISD::Weather::Status >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(const QString & )>(_a, &SchedulerProcess::newLog, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(SchedulerState )>(_a, &SchedulerProcess::newStatus, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(ISD::Weather::Status )>(_a, &SchedulerProcess::newWeatherStatus, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)()>(_a, &SchedulerProcess::schedulerStopped, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)()>(_a, &SchedulerProcess::shutdownStarted, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(bool , bool )>(_a, &SchedulerProcess::schedulerSleeping, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)()>(_a, &SchedulerProcess::schedulerPaused, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(QString , bool )>(_a, &SchedulerProcess::changeSleepLabel, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(QJsonArray )>(_a, &SchedulerProcess::jobsUpdated, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(SchedulerJob * )>(_a, &SchedulerProcess::updateJobTable, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)()>(_a, &SchedulerProcess::clearJobTable, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(const QString & )>(_a, &SchedulerProcess::changeCurrentSequence, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(QDBusInterface * )>(_a, &SchedulerProcess::interfaceReady, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(SchedulerJob * )>(_a, &SchedulerProcess::addJob, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)()>(_a, &SchedulerProcess::syncGreedyParams, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)()>(_a, &SchedulerProcess::syncGUIToGeneralSettings, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(const QString & )>(_a, &SchedulerProcess::updateSchedulerURL, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(double )>(_a, &SchedulerProcess::targetDistance, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(const QString & )>(_a, &SchedulerProcess::jobStarted, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (SchedulerProcess::*)(const QString & , const QString & )>(_a, &SchedulerProcess::jobEnded, 21))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Ekos::SchedulerState >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<Ekos::SchedulerState*>(_v) = _t->status(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->profile(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->currentJobName(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->currentJobJson(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->jsonJobs(); break;
        case 5: *reinterpret_cast<QStringList*>(_v) = _t->logText(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 1: _t->setProfile(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

void *Ekos::SchedulerProcess::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Ekos16SchedulerProcessE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "ModuleLogger"))
        return static_cast< ModuleLogger*>(this);
    return QObject::qt_metacast(_clname);
}

int Ekos::SchedulerProcess::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 < 71)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 71;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 71)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 71;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    }
    return _id;
}

// SIGNAL 0
void Ekos::SchedulerProcess::newLog(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Ekos::SchedulerProcess::newStatus(SchedulerState _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Ekos::SchedulerProcess::newWeatherStatus(ISD::Weather::Status _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Ekos::SchedulerProcess::schedulerStopped()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void Ekos::SchedulerProcess::shutdownStarted()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void Ekos::SchedulerProcess::schedulerSleeping(bool _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2);
}

// SIGNAL 6
void Ekos::SchedulerProcess::schedulerPaused()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void Ekos::SchedulerProcess::changeSleepLabel(QString _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2);
}

// SIGNAL 9
void Ekos::SchedulerProcess::jobsUpdated(QJsonArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Ekos::SchedulerProcess::updateJobTable(SchedulerJob * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 12
void Ekos::SchedulerProcess::clearJobTable()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void Ekos::SchedulerProcess::changeCurrentSequence(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Ekos::SchedulerProcess::interfaceReady(QDBusInterface * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Ekos::SchedulerProcess::addJob(SchedulerJob * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void Ekos::SchedulerProcess::syncGreedyParams()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void Ekos::SchedulerProcess::syncGUIToGeneralSettings()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void Ekos::SchedulerProcess::updateSchedulerURL(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void Ekos::SchedulerProcess::targetDistance(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void Ekos::SchedulerProcess::jobStarted(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void Ekos::SchedulerProcess::jobEnded(const QString & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1, _t2);
}
QT_WARNING_POP
