/****************************************************************************
** Meta object code from reading C++ file 'guide.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/guide/guide.h"
#include <QtNetwork/QSslError>
#include <QtDataVisualization/qbar3dseries.h>
#include <QtDataVisualization/q3dscene.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 'guide.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_ZN4Ekos5GuideE_t {};
} // unnamed namespace

template <> constexpr inline auto Ekos::Guide::qt_create_metaobjectdata<qt_meta_tag_ZN4Ekos5GuideE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Ekos::Guide",
        "D-Bus Interface",
        "org.kde.kstars.Ekos.Guide",
        "newLog",
        "",
        "text",
        "newStatus",
        "Ekos::GuideState",
        "status",
        "newImage",
        "QSharedPointer<FITSView>",
        "view",
        "newStarPixmap",
        "QPixmap&",
        "trainChanged",
        "newTrainingData",
        "QJsonObject",
        "sysidData",
        "newAxisDelta",
        "ra",
        "de",
        "newAxisSigma",
        "guideStats",
        "raError",
        "decError",
        "raPulse",
        "decPulse",
        "snr",
        "skyBg",
        "numStars",
        "guideChipUpdated",
        "ISD::CameraChip*",
        "settingsUpdated",
        "QVariantMap",
        "settings",
        "driverTimedout",
        "deviceName",
        "newAIGuideProgress",
        "current",
        "total",
        "newAIGuideLog",
        "message",
        "newAIGuideComplete",
        "newAIGuideTrainingProgress",
        "newAIGuideTrainingComplete",
        "newAIGuideTrainingError",
        "error",
        "updateTrainingWeight",
        "success",
        "result",
        "guide",
        "setAIFreeDrift",
        "enable",
        "isAIFreeDrift",
        "isStreamingGuide",
        "abort",
        "calibrate",
        "clearCalibration",
        "Q_NOREPLY",
        "reloadAIWeights",
        "dither",
        "resetNonGuidedDither",
        "suspend",
        "resume",
        "capture",
        "loop",
        "setSubFrameEnabled",
        "setAutoStarEnabled",
        "setGuiderType",
        "type",
        "axisDelta",
        "QList<double>",
        "axisSigma",
        "checkCamera",
        "checkExposureValue",
        "targetChip",
        "exposure",
        "IPState",
        "expState",
        "processData",
        "QSharedPointer<FITSData>",
        "data",
        "abortExposure",
        "setRecommendedExposureValues",
        "values",
        "appendLogText",
        "setStatus",
        "newState",
        "setCaptureStatus",
        "Ekos::CaptureState",
        "setMountStatus",
        "ISD::Mount::Status",
        "setMountCoords",
        "SkyPoint",
        "position",
        "ISD::Mount::PierSide",
        "pierSide",
        "dms",
        "ha",
        "setPierSide",
        "newSide",
        "setStarPosition",
        "QVector3D",
        "newCenter",
        "updateNow",
        "setCaptureComplete",
        "sendMultiPulse",
        "GuideDirection",
        "ra_dir",
        "ra_msecs",
        "dec_dir",
        "dec_msecs",
        "CaptureAfterPulses",
        "followWithCapture",
        "sendSinglePulse",
        "dir",
        "msecs",
        "setDECSwap",
        "updateSetting",
        "key",
        "QVariant",
        "value",
        "saveGPGPeriod",
        "handleVerticalPlotSizeChange",
        "handleHorizontalPlotSizeChange",
        "clearGuideGraphs",
        "clearCalibrationGraphs",
        "slotAutoScaleGraphs",
        "buildTarget",
        "guideHistory",
        "setLatestGuidePoint",
        "isChecked",
        "updateDirectionsFromPHD2",
        "mode",
        "guideAfterMeridianFlip",
        "opticalTrain",
        "setOpticalTrain",
        "updateCCDBin",
        "index",
        "updateProperty",
        "INDI::Property",
        "prop",
        "setTrackingStar",
        "x",
        "y",
        "saveDefaultGuideExposure",
        "updateTrackingBoxSize",
        "currentIndex",
        "onSettingsUpdated",
        "starDetectionIndex",
        "onEnableDirRA",
        "onEnableDirDEC",
        "setAxisDelta",
        "setAxisSigma",
        "setAxisPulse",
        "setSNR",
        "calibrationUpdate",
        "GuideInterface::CalibrationUpdateType",
        "dx",
        "dy",
        "guideInfo",
        "info",
        "processGuideOptions",
        "configSEPMultistarOptions",
        "onControlDirectionChanged",
        "loadAIWeights",
        "showFITSViewer",
        "displayGuideView",
        "enabled",
        "processCaptureTimeout",
        "nonGuidedDither",
        "camera",
        "guider",
        "focalLength",
        "pixelSizeX",
        "connectGuider",
        "disconnectGuider",
        "setExposure",
        "setDarkFrameEnabled",
        "clearLog",
        "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(Ekos::GuideState)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Signal 'newImage'
        QtMocHelpers::SignalData<void(const QSharedPointer<FITSView> &)>(9, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 11 },
        }}),
        // Signal 'newStarPixmap'
        QtMocHelpers::SignalData<void(QPixmap &)>(12, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 4 },
        }}),
        // Signal 'trainChanged'
        QtMocHelpers::SignalData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newTrainingData'
        QtMocHelpers::SignalData<void(const QJsonObject &)>(15, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 },
        }}),
        // Signal 'newAxisDelta'
        QtMocHelpers::SignalData<void(double, double)>(18, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 19 }, { QMetaType::Double, 20 },
        }}),
        // Signal 'newAxisSigma'
        QtMocHelpers::SignalData<void(double, double)>(21, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 19 }, { QMetaType::Double, 20 },
        }}),
        // Signal 'guideStats'
        QtMocHelpers::SignalData<void(double, double, int, int, double, double, int)>(22, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 23 }, { QMetaType::Double, 24 }, { QMetaType::Int, 25 }, { QMetaType::Int, 26 },
            { QMetaType::Double, 27 }, { QMetaType::Double, 28 }, { QMetaType::Int, 29 },
        }}),
        // Signal 'guideChipUpdated'
        QtMocHelpers::SignalData<void(ISD::CameraChip *)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 31, 4 },
        }}),
        // Signal 'settingsUpdated'
        QtMocHelpers::SignalData<void(const QVariantMap &)>(32, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 33, 34 },
        }}),
        // Signal 'driverTimedout'
        QtMocHelpers::SignalData<void(const QString &)>(35, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 },
        }}),
        // Signal 'newAIGuideProgress'
        QtMocHelpers::SignalData<void(int, int, const QString &)>(37, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 38 }, { QMetaType::Int, 39 }, { QMetaType::QString, 8 },
        }}),
        // Signal 'newAIGuideLog'
        QtMocHelpers::SignalData<void(const QString &)>(40, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'newAIGuideComplete'
        QtMocHelpers::SignalData<void()>(42, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newAIGuideTrainingProgress'
        QtMocHelpers::SignalData<void(const QString &)>(43, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'newAIGuideTrainingComplete'
        QtMocHelpers::SignalData<void()>(44, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newAIGuideTrainingError'
        QtMocHelpers::SignalData<void(const QString &)>(45, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 46 },
        }}),
        // Slot 'updateTrainingWeight'
        QtMocHelpers::SlotData<void(bool, const QJsonObject &)>(47, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 48 }, { 0x80000000 | 16, 49 },
        }}),
        // Slot 'guide'
        QtMocHelpers::SlotData<bool()>(50, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'setAIFreeDrift'
        QtMocHelpers::SlotData<void(bool)>(51, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 52 },
        }}),
        // Slot 'isAIFreeDrift'
        QtMocHelpers::SlotData<bool() const>(53, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isStreamingGuide'
        QtMocHelpers::SlotData<bool() const>(54, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'abort'
        QtMocHelpers::SlotData<bool()>(55, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'calibrate'
        QtMocHelpers::SlotData<bool()>(56, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'clearCalibration'
        QtMocHelpers::SlotData<void()>(57, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'reloadAIWeights'
        QtMocHelpers::SlotData<void()>(59, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'dither'
        QtMocHelpers::SlotData<bool()>(60, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'resetNonGuidedDither'
        QtMocHelpers::SlotData<void()>(61, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'suspend'
        QtMocHelpers::SlotData<bool()>(62, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'resume'
        QtMocHelpers::SlotData<bool()>(63, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'capture'
        QtMocHelpers::SlotData<bool()>(64, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Slot 'loop'
        QtMocHelpers::SlotData<void()>(65, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
        // Slot 'setSubFrameEnabled'
        QtMocHelpers::SlotData<void(bool)>(66, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 52 },
        }}),
        // Slot 'setAutoStarEnabled'
        QtMocHelpers::SlotData<void(bool)>(67, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 52 },
        }}),
        // Slot 'setGuiderType'
        QtMocHelpers::SlotData<bool(int)>(68, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool, {{
            { QMetaType::Int, 69 },
        }}),
        // Slot 'axisDelta'
        QtMocHelpers::SlotData<QList<double>()>(70, 4, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 71),
        // Slot 'axisSigma'
        QtMocHelpers::SlotData<QList<double>()>(72, 4, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 71),
        // Slot 'checkCamera'
        QtMocHelpers::SlotData<void()>(73, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkExposureValue'
        QtMocHelpers::SlotData<void(ISD::CameraChip *, double, IPState)>(74, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 31, 75 }, { QMetaType::Double, 76 }, { 0x80000000 | 77, 78 },
        }}),
        // Slot 'processData'
        QtMocHelpers::SlotData<void(const QSharedPointer<FITSData> &)>(79, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 80, 81 },
        }}),
        // Slot 'abortExposure'
        QtMocHelpers::SlotData<void()>(82, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setRecommendedExposureValues'
        QtMocHelpers::SlotData<QString(QList<double>)>(83, 4, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 71, 84 },
        }}),
        // Slot 'appendLogText'
        QtMocHelpers::SlotData<void(const QString &)>(85, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'setStatus'
        QtMocHelpers::SlotData<void(Ekos::GuideState)>(86, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 87 },
        }}),
        // Slot 'setCaptureStatus'
        QtMocHelpers::SlotData<void(Ekos::CaptureState)>(88, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 89, 87 },
        }}),
        // Slot 'setMountStatus'
        QtMocHelpers::SlotData<void(ISD::Mount::Status)>(90, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 91, 87 },
        }}),
        // Slot 'setMountCoords'
        QtMocHelpers::SlotData<void(const SkyPoint &, ISD::Mount::PierSide, const dms &)>(92, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 93, 94 }, { 0x80000000 | 95, 96 }, { 0x80000000 | 97, 98 },
        }}),
        // Slot 'setPierSide'
        QtMocHelpers::SlotData<void(ISD::Mount::PierSide)>(99, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 95, 100 },
        }}),
        // Slot 'setStarPosition'
        QtMocHelpers::SlotData<void(const QVector3D &, bool)>(101, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 102, 103 }, { QMetaType::Bool, 104 },
        }}),
        // Slot 'setCaptureComplete'
        QtMocHelpers::SlotData<void()>(105, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sendMultiPulse'
        QtMocHelpers::SlotData<bool(GuideDirection, int, GuideDirection, int, CaptureAfterPulses)>(106, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 107, 108 }, { QMetaType::Int, 109 }, { 0x80000000 | 107, 110 }, { QMetaType::Int, 111 },
            { 0x80000000 | 112, 113 },
        }}),
        // Slot 'sendSinglePulse'
        QtMocHelpers::SlotData<bool(GuideDirection, int, CaptureAfterPulses)>(114, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 107, 115 }, { QMetaType::Int, 116 }, { 0x80000000 | 112, 113 },
        }}),
        // Slot 'setDECSwap'
        QtMocHelpers::SlotData<void(bool)>(117, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 52 },
        }}),
        // Slot 'updateSetting'
        QtMocHelpers::SlotData<void(const QString &, const QVariant &)>(118, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 119 }, { 0x80000000 | 120, 121 },
        }}),
        // Slot 'saveGPGPeriod'
        QtMocHelpers::SlotData<void()>(122, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'handleVerticalPlotSizeChange'
        QtMocHelpers::SlotData<void()>(123, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'handleHorizontalPlotSizeChange'
        QtMocHelpers::SlotData<void()>(124, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearGuideGraphs'
        QtMocHelpers::SlotData<void()>(125, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearCalibrationGraphs'
        QtMocHelpers::SlotData<void()>(126, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotAutoScaleGraphs'
        QtMocHelpers::SlotData<void()>(127, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'buildTarget'
        QtMocHelpers::SlotData<void()>(128, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'guideHistory'
        QtMocHelpers::SlotData<void()>(129, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setLatestGuidePoint'
        QtMocHelpers::SlotData<void(bool)>(130, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 131 },
        }}),
        // Slot 'updateDirectionsFromPHD2'
        QtMocHelpers::SlotData<void(const QString &)>(132, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 133 },
        }}),
        // Slot 'guideAfterMeridianFlip'
        QtMocHelpers::SlotData<void()>(134, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'opticalTrain'
        QtMocHelpers::SlotData<QString() const>(135, 4, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setOpticalTrain'
        QtMocHelpers::SlotData<void(const QString &)>(136, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 121 },
        }}),
        // Slot 'updateCCDBin'
        QtMocHelpers::SlotData<void(int)>(137, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 138 },
        }}),
        // Slot 'updateProperty'
        QtMocHelpers::SlotData<void(INDI::Property)>(139, 4, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 140, 141 },
        }}),
        // Slot 'setTrackingStar'
        QtMocHelpers::SlotData<void(int, int)>(142, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 143 }, { QMetaType::Int, 144 },
        }}),
        // Slot 'saveDefaultGuideExposure'
        QtMocHelpers::SlotData<void()>(145, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'updateTrackingBoxSize'
        QtMocHelpers::SlotData<void(int)>(146, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 147 },
        }}),
        // Slot 'onSettingsUpdated'
        QtMocHelpers::SlotData<void(int)>(148, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Int, 149 },
        }}),
        // Slot 'onEnableDirRA'
        QtMocHelpers::SlotData<void()>(150, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onEnableDirDEC'
        QtMocHelpers::SlotData<void()>(151, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'setAxisDelta'
        QtMocHelpers::SlotData<void(double, double)>(152, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 19 }, { QMetaType::Double, 20 },
        }}),
        // Slot 'setAxisSigma'
        QtMocHelpers::SlotData<void(double, double)>(153, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 19 }, { QMetaType::Double, 20 },
        }}),
        // Slot 'setAxisPulse'
        QtMocHelpers::SlotData<void(double, double)>(154, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 19 }, { QMetaType::Double, 20 },
        }}),
        // Slot 'setSNR'
        QtMocHelpers::SlotData<void(double)>(155, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Double, 27 },
        }}),
        // Slot 'calibrationUpdate'
        QtMocHelpers::SlotData<void(GuideInterface::CalibrationUpdateType, const QString &, double, double)>(156, 4, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 157, 69 }, { QMetaType::QString, 41 }, { QMetaType::Double, 158 }, { QMetaType::Double, 159 },
        }}),
        // Slot 'calibrationUpdate'
        QtMocHelpers::SlotData<void(GuideInterface::CalibrationUpdateType, const QString &, double)>(156, 4, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 157, 69 }, { QMetaType::QString, 41 }, { QMetaType::Double, 158 },
        }}),
        // Slot 'calibrationUpdate'
        QtMocHelpers::SlotData<void(GuideInterface::CalibrationUpdateType, const QString &)>(156, 4, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 157, 69 }, { QMetaType::QString, 41 },
        }}),
        // Slot 'calibrationUpdate'
        QtMocHelpers::SlotData<void(GuideInterface::CalibrationUpdateType)>(156, 4, QMC::AccessProtected | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 157, 69 },
        }}),
        // Slot 'guideInfo'
        QtMocHelpers::SlotData<void(const QString &)>(160, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 161 },
        }}),
        // Slot 'processGuideOptions'
        QtMocHelpers::SlotData<void()>(162, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'configSEPMultistarOptions'
        QtMocHelpers::SlotData<void()>(163, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onControlDirectionChanged'
        QtMocHelpers::SlotData<void()>(164, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'loadAIWeights'
        QtMocHelpers::SlotData<void()>(165, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'showFITSViewer'
        QtMocHelpers::SlotData<void()>(166, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'displayGuideView'
        QtMocHelpers::SlotData<void(bool)>(167, 4, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 168 },
        }}),
        // Slot 'processCaptureTimeout'
        QtMocHelpers::SlotData<void()>(169, 4, QMC::AccessProtected, QMetaType::Void),
        // Slot 'nonGuidedDither'
        QtMocHelpers::SlotData<void()>(170, 4, QMC::AccessProtected, QMetaType::Void),
        // Method 'camera'
        QtMocHelpers::MethodData<QString()>(171, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Method 'guider'
        QtMocHelpers::MethodData<QString()>(172, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Method 'focalLength'
        QtMocHelpers::MethodData<double() const>(173, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Double),
        // Method 'pixelSizeX'
        QtMocHelpers::MethodData<double() const>(174, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Double),
        // Method 'connectGuider'
        QtMocHelpers::MethodData<bool()>(175, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Method 'disconnectGuider'
        QtMocHelpers::MethodData<bool()>(176, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Bool),
        // Method 'status'
        QtMocHelpers::MethodData<Ekos::GuideState()>(8, 4, QMC::AccessPublic | QMC::MethodScriptable, 0x80000000 | 7),
        // Method 'setExposure'
        QtMocHelpers::MethodData<void(double)>(177, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Double, 121 },
        }}),
        // Method 'setDarkFrameEnabled'
        QtMocHelpers::MethodData<void(bool)>(178, 58, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::Bool, 52 },
        }}),
        // Method 'clearLog'
        QtMocHelpers::MethodData<void()>(179, 4, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'status'
        QtMocHelpers::PropertyData<Ekos::GuideState>(8, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'logText'
        QtMocHelpers::PropertyData<QStringList>(180, QMetaType::QStringList, QMC::DefaultPropertyFlags, 0),
        // property 'opticalTrain'
        QtMocHelpers::PropertyData<QString>(135, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'camera'
        QtMocHelpers::PropertyData<QString>(171, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'guider'
        QtMocHelpers::PropertyData<QString>(172, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'exposure'
        QtMocHelpers::PropertyData<double>(76, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'axisDelta'
        QtMocHelpers::PropertyData<QList<double>>(70, 0x80000000 | 71, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 6),
        // property 'axisSigma'
        QtMocHelpers::PropertyData<QList<double>>(72, 0x80000000 | 71, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<Guide, qt_meta_tag_ZN4Ekos5GuideE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Ekos::Guide::staticMetaObject = { {
    QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Ekos5GuideE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Ekos5GuideE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4Ekos5GuideE_t>.metaTypes,
    nullptr
} };

void Ekos::Guide::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Guide *>(_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<Ekos::GuideState>>(_a[1]))); break;
        case 2: _t->newImage((*reinterpret_cast<std::add_pointer_t<QSharedPointer<FITSView>>>(_a[1]))); break;
        case 3: _t->newStarPixmap((*reinterpret_cast<std::add_pointer_t<QPixmap&>>(_a[1]))); break;
        case 4: _t->trainChanged(); break;
        case 5: _t->newTrainingData((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1]))); break;
        case 6: _t->newAxisDelta((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 7: _t->newAxisSigma((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 8: _t->guideStats((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[7]))); break;
        case 9: _t->guideChipUpdated((*reinterpret_cast<std::add_pointer_t<ISD::CameraChip*>>(_a[1]))); break;
        case 10: _t->settingsUpdated((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 11: _t->driverTimedout((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 12: _t->newAIGuideProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 13: _t->newAIGuideLog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->newAIGuideComplete(); break;
        case 15: _t->newAIGuideTrainingProgress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 16: _t->newAIGuideTrainingComplete(); break;
        case 17: _t->newAIGuideTrainingError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: _t->updateTrainingWeight((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[2]))); break;
        case 19: { bool _r = _t->guide();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 20: _t->setAIFreeDrift((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: { bool _r = _t->isAIFreeDrift();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 22: { bool _r = _t->isStreamingGuide();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 23: { bool _r = _t->abort();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 24: { bool _r = _t->calibrate();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 25: _t->clearCalibration(); break;
        case 26: _t->reloadAIWeights(); break;
        case 27: { bool _r = _t->dither();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 28: _t->resetNonGuidedDither(); break;
        case 29: { bool _r = _t->suspend();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 30: { bool _r = _t->resume();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 31: { bool _r = _t->capture();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 32: _t->loop(); break;
        case 33: _t->setSubFrameEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 34: _t->setAutoStarEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: { bool _r = _t->setGuiderType((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: { QList<double> _r = _t->axisDelta();
            if (_a[0]) *reinterpret_cast<QList<double>*>(_a[0]) = std::move(_r); }  break;
        case 37: { QList<double> _r = _t->axisSigma();
            if (_a[0]) *reinterpret_cast<QList<double>*>(_a[0]) = std::move(_r); }  break;
        case 38: _t->checkCamera(); break;
        case 39: _t->checkExposureValue((*reinterpret_cast<std::add_pointer_t<ISD::CameraChip*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<IPState>>(_a[3]))); break;
        case 40: _t->processData((*reinterpret_cast<std::add_pointer_t<QSharedPointer<FITSData>>>(_a[1]))); break;
        case 41: _t->abortExposure(); break;
        case 42: { QString _r = _t->setRecommendedExposureValues((*reinterpret_cast<std::add_pointer_t<QList<double>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 43: _t->appendLogText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 44: _t->setStatus((*reinterpret_cast<std::add_pointer_t<Ekos::GuideState>>(_a[1]))); break;
        case 45: _t->setCaptureStatus((*reinterpret_cast<std::add_pointer_t<Ekos::CaptureState>>(_a[1]))); break;
        case 46: _t->setMountStatus((*reinterpret_cast<std::add_pointer_t<ISD::Mount::Status>>(_a[1]))); break;
        case 47: _t->setMountCoords((*reinterpret_cast<std::add_pointer_t<SkyPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<ISD::Mount::PierSide>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<dms>>(_a[3]))); break;
        case 48: _t->setPierSide((*reinterpret_cast<std::add_pointer_t<ISD::Mount::PierSide>>(_a[1]))); break;
        case 49: _t->setStarPosition((*reinterpret_cast<std::add_pointer_t<QVector3D>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 50: _t->setCaptureComplete(); break;
        case 51: { bool _r = _t->sendMultiPulse((*reinterpret_cast<std::add_pointer_t<GuideDirection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<GuideDirection>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<CaptureAfterPulses>>(_a[5])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 52: { bool _r = _t->sendSinglePulse((*reinterpret_cast<std::add_pointer_t<GuideDirection>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<CaptureAfterPulses>>(_a[3])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 53: _t->setDECSwap((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: _t->updateSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 55: _t->saveGPGPeriod(); break;
        case 56: _t->handleVerticalPlotSizeChange(); break;
        case 57: _t->handleHorizontalPlotSizeChange(); break;
        case 58: _t->clearGuideGraphs(); break;
        case 59: _t->clearCalibrationGraphs(); break;
        case 60: _t->slotAutoScaleGraphs(); break;
        case 61: _t->buildTarget(); break;
        case 62: _t->guideHistory(); break;
        case 63: _t->setLatestGuidePoint((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: _t->updateDirectionsFromPHD2((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->guideAfterMeridianFlip(); break;
        case 66: { QString _r = _t->opticalTrain();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 67: _t->setOpticalTrain((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 68: _t->updateCCDBin((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 69: _t->updateProperty((*reinterpret_cast<std::add_pointer_t<INDI::Property>>(_a[1]))); break;
        case 70: _t->setTrackingStar((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 71: _t->saveDefaultGuideExposure(); break;
        case 72: _t->updateTrackingBoxSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 73: _t->onSettingsUpdated((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 74: _t->onEnableDirRA(); break;
        case 75: _t->onEnableDirDEC(); break;
        case 76: _t->setAxisDelta((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 77: _t->setAxisSigma((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 78: _t->setAxisPulse((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 79: _t->setSNR((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 80: _t->calibrationUpdate((*reinterpret_cast<std::add_pointer_t<GuideInterface::CalibrationUpdateType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[4]))); break;
        case 81: _t->calibrationUpdate((*reinterpret_cast<std::add_pointer_t<GuideInterface::CalibrationUpdateType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3]))); break;
        case 82: _t->calibrationUpdate((*reinterpret_cast<std::add_pointer_t<GuideInterface::CalibrationUpdateType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 83: _t->calibrationUpdate((*reinterpret_cast<std::add_pointer_t<GuideInterface::CalibrationUpdateType>>(_a[1]))); break;
        case 84: _t->guideInfo((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 85: _t->processGuideOptions(); break;
        case 86: _t->configSEPMultistarOptions(); break;
        case 87: _t->onControlDirectionChanged(); break;
        case 88: _t->loadAIWeights(); break;
        case 89: _t->showFITSViewer(); break;
        case 90: _t->displayGuideView((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 91: _t->processCaptureTimeout(); break;
        case 92: _t->nonGuidedDither(); break;
        case 93: { QString _r = _t->camera();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 94: { QString _r = _t->guider();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 95: { double _r = _t->focalLength();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 96: { double _r = _t->pixelSizeX();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 97: { bool _r = _t->connectGuider();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 98: { bool _r = _t->disconnectGuider();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 99: { Ekos::GuideState _r = _t->status();
            if (_a[0]) *reinterpret_cast<Ekos::GuideState*>(_a[0]) = std::move(_r); }  break;
        case 100: _t->setExposure((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 101: _t->setDarkFrameEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 102: _t->clearLog(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); 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< Ekos::GuideState >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QSharedPointer<FITSView> >(); 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< QSharedPointer<FITSData> >(); break;
            }
            break;
        case 42:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<double> >(); break;
            }
            break;
        case 44:
            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 45:
            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 46:
            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 47:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ISD::Mount::PierSide >(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< SkyPoint >(); break;
            }
            break;
        case 48:
            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::PierSide >(); break;
            }
            break;
        case 69:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< INDI::Property >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QString & )>(_a, &Guide::newLog, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(Ekos::GuideState )>(_a, &Guide::newStatus, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QSharedPointer<FITSView> & )>(_a, &Guide::newImage, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(QPixmap & )>(_a, &Guide::newStarPixmap, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)()>(_a, &Guide::trainChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QJsonObject & )>(_a, &Guide::newTrainingData, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(double , double )>(_a, &Guide::newAxisDelta, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(double , double )>(_a, &Guide::newAxisSigma, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(double , double , int , int , double , double , int )>(_a, &Guide::guideStats, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(ISD::CameraChip * )>(_a, &Guide::guideChipUpdated, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QVariantMap & )>(_a, &Guide::settingsUpdated, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QString & )>(_a, &Guide::driverTimedout, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(int , int , const QString & )>(_a, &Guide::newAIGuideProgress, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QString & )>(_a, &Guide::newAIGuideLog, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)()>(_a, &Guide::newAIGuideComplete, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QString & )>(_a, &Guide::newAIGuideTrainingProgress, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)()>(_a, &Guide::newAIGuideTrainingComplete, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Guide::*)(const QString & )>(_a, &Guide::newAIGuideTrainingError, 17))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Ekos::GuideState >(); break;
        case 7:
        case 6:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<double> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<Ekos::GuideState*>(_v) = _t->status(); break;
        case 1: *reinterpret_cast<QStringList*>(_v) = _t->logText(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->opticalTrain(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->camera(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->guider(); break;
        case 5: *reinterpret_cast<double*>(_v) = _t->exposure(); break;
        case 6: *reinterpret_cast<QList<double>*>(_v) = _t->axisDelta(); break;
        case 7: *reinterpret_cast<QList<double>*>(_v) = _t->axisSigma(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 2: _t->setOpticalTrain(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setExposure(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}

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

void *Ekos::Guide::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Ekos5GuideE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "Ui::Guide"))
        return static_cast< Ui::Guide*>(this);
    return QWidget::qt_metacast(_clname);
}

int Ekos::Guide::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QWidget::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 103)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 103;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 103)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 103;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

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

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

// SIGNAL 2
void Ekos::Guide::newImage(const QSharedPointer<FITSView> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Ekos::Guide::newStarPixmap(QPixmap & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

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

// SIGNAL 5
void Ekos::Guide::newTrainingData(const QJsonObject & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Ekos::Guide::newAxisDelta(double _t1, double _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void Ekos::Guide::newAxisSigma(double _t1, double _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2);
}

// SIGNAL 8
void Ekos::Guide::guideStats(double _t1, double _t2, int _t3, int _t4, double _t5, double _t6, int _t7)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2, _t3, _t4, _t5, _t6, _t7);
}

// SIGNAL 9
void Ekos::Guide::guideChipUpdated(ISD::CameraChip * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Ekos::Guide::settingsUpdated(const QVariantMap & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void Ekos::Guide::driverTimedout(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void Ekos::Guide::newAIGuideProgress(int _t1, int _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2, _t3);
}

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

// SIGNAL 14
void Ekos::Guide::newAIGuideComplete()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void Ekos::Guide::newAIGuideTrainingProgress(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

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

// SIGNAL 17
void Ekos::Guide::newAIGuideTrainingError(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}
QT_WARNING_POP
