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

template <> constexpr inline auto CaptureAdaptor::qt_create_metaobjectdata<qt_meta_tag_ZN14CaptureAdaptorE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CaptureAdaptor",
        "D-Bus Interface",
        "org.kde.kstars.Ekos.Capture",
        "D-Bus Introspection",
        "  <interface name=\"org.kde.kstars.Ekos.Capture\">\n    <property "
        "access=\"readwrite\" type=\"s\" name=\"targetName\"/>\n    <proper"
        "ty access=\"readwrite\" type=\"s\" name=\"observerName\"/>\n    <p"
        "roperty access=\"readwrite\" type=\"s\" name=\"opticalTrain\"/>\n "
        "   <property access=\"read\" type=\"s\" name=\"camera\"/>\n    <pr"
        "operty access=\"read\" type=\"s\" name=\"filterWheel\"/>\n    <pro"
        "perty access=\"readwrite\" type=\"s\" name=\"filter\"/>\n    <prop"
        "erty access=\"readwrite\" type=\"b\" name=\"coolerControl\"/>\n   "
        " <property access=\"read\" type=\"as\" name=\"logText\"/>\n    <pr"
        "operty access=\"read\" type=\"i\" name=\"status\">\n      <annotat"
        "ion value=\"Ekos::CaptureState\" name=\"org.qtproject.QtDBus.QtTyp"
        "eName\"/>\n    </property>\n    <method name=\"start\">\n      <ar"
        "g direction=\"in\" type=\"s\" name=\"train\"/>\n      <arg directi"
        "on=\"out\" type=\"s\"/>\n    </method>\n    <method name=\"abort\""
        ">\n      <arg direction=\"in\" type=\"s\" name=\"train\"/>\n      "
        "<annotation value=\"true\" name=\"org.freedesktop.DBus.Method.NoRe"
        "ply\"/>\n    </method>\n    <method name=\"suspend\">\n      <anno"
        "tation value=\"true\" name=\"org.freedesktop.DBus.Method.NoReply\""
        "/>\n    </method>\n    <method name=\"stop\">\n      <annotation v"
        "alue=\"true\" name=\"org.freedesktop.DBus.Method.NoReply\"/>\n    "
        "</method>\n    <method name=\"pause\">\n      <annotation value=\""
        "true\" name=\"org.freedesktop.DBus.Method.NoReply\"/>\n    </metho"
        "d>\n    <method name=\"toggleSequence\">\n      <annotation value="
        "\"true\" name=\"org.freedesktop.DBus.Method.NoReply\"/>\n    </met"
        "hod>\n    <method name=\"restartCamera\">\n      <arg direction=\""
        "in\" type=\"s\" name=\"name\"/>\n      <annotation value=\"true\" "
        "name=\"org.freedesktop.DBus.Method.NoReply\"/>\n    </method>\n   "
        " <method name=\"toggleVideo\">\n      <arg direction=\"in\" type=\""
        "b\" name=\"enabled\"/>\n      <annotation value=\"true\" name=\"or"
        "g.freedesktop.DBus.Method.NoReply\"/>\n    </method>\n    <method "
        "name=\"findCameraPosition\">\n      <arg direction=\"out\" type=\""
        "i\"/>\n      <arg direction=\"in\" type=\"s\" name=\"train\"/>\n  "
        "    <arg direction=\"in\" type=\"b\" name=\"addIfNecessary\"/>\n  "
        "  </method>\n    <method name=\"loadSequenceQueue\">\n      <arg d"
        "irection=\"out\" type=\"b\"/>\n      <arg direction=\"in\" type=\""
        "s\" name=\"fileURL\"/>\n      <arg direction=\"in\" type=\"s\" nam"
        "e=\"train\"/>\n      <arg direction=\"in\" type=\"b\" name=\"isMas"
        "ter\"/>\n      <arg direction=\"in\" type=\"s\" name=\"targetName\""
        "/>\n    </method>\n    <method name=\"saveSequenceQueue\">\n      "
        "<arg direction=\"out\" type=\"b\"/>\n      <arg direction=\"in\" t"
        "ype=\"s\" name=\"path\"/>\n    </method>\n    <method name=\"clear"
        "SequenceQueue\">\n      <annotation value=\"true\" name=\"org.free"
        "desktop.DBus.Method.NoReply\"/>\n    </method>\n    <method name=\""
        "getSequenceQueueStatus\">\n      <arg direction=\"out\" type=\"s\""
        "/>\n    </method>\n    <method name=\"setMaximumGuidingDeviation\""
        ">\n      <arg direction=\"in\" type=\"b\" name=\"enable\"/>\n     "
        " <arg direction=\"in\" type=\"d\" name=\"value\"/>\n      <annotat"
        "ion value=\"true\" name=\"org.freedesktop.DBus.Method.NoReply\"/>\n"
        "    </method>\n    <method name=\"setInSequenceFocus\">\n      <ar"
        "g direction=\"in\" type=\"b\" name=\"enable\"/>\n      <arg direct"
        "ion=\"in\" type=\"d\" name=\"HFR\"/>\n      <annotation value=\"tr"
        "ue\" name=\"org.freedesktop.DBus.Method.NoReply\"/>\n    </method>"
        "\n    <method name=\"getJobCount\">\n      <arg direction=\"out\" "
        "type=\"i\"/>\n    </method>\n    <method name=\"getPendingJobCount"
        "\">\n      <arg direction=\"out\" type=\"i\"/>\n    </method>\n   "
        " <method name=\"getJobState\">\n      <arg direction=\"out\" type="
        "\"s\"/>\n      <arg direction=\"in\" type=\"i\" name=\"id\"/>\n   "
        " </method>\n    <method name=\"getJobFilterName\">\n      <arg dir"
        "ection=\"out\" type=\"s\"/>\n      <arg direction=\"in\" type=\"i\""
        " name=\"id\"/>\n    </method>\n    <method name=\"getJobImageProgr"
        "ess\">\n      <arg direction=\"out\" type=\"i\"/>\n      <arg dire"
        "ction=\"in\" type=\"i\" name=\"id\"/>\n    </method>\n    <method "
        "name=\"getJobImageCount\">\n      <arg direction=\"out\" type=\"i\""
        "/>\n      <arg direction=\"in\" type=\"i\" name=\"id\"/>\n    </me"
        "thod>\n    <method name=\"getJobExposureProgress\">\n      <arg di"
        "rection=\"out\" type=\"d\"/>\n      <arg direction=\"in\" type=\"i"
        "\" name=\"id\"/>\n    </method>\n    <method name=\"getJobExposure"
        "Duration\">\n      <arg direction=\"out\" type=\"d\"/>\n      <arg"
        " direction=\"in\" type=\"i\" name=\"id\"/>\n    </method>\n    <me"
        "thod name=\"getJobFrameType\">\n      <arg direction=\"out\" type="
        "\"i\"/>\n      <arg direction=\"in\" type=\"i\" name=\"id\"/>\n   "
        " </method>\n    <method name=\"getJobPlaceholderFormat\">\n      <"
        "arg direction=\"out\" type=\"s\"/>\n    </method>\n    <method nam"
        "e=\"getJobPreviewFileName\">\n      <arg direction=\"out\" type=\""
        "s\"/>\n    </method>\n    <method name=\"getProgressPercentage\">\n"
        "      <arg direction=\"out\" type=\"d\"/>\n    </method>\n    <met"
        "hod name=\"getActiveJobID\">\n      <arg direction=\"out\" type=\""
        "i\"/>\n    </method>\n    <method name=\"getActiveJobRemainingTime"
        "\">\n      <arg direction=\"out\" type=\"i\"/>\n    </method>\n   "
        " <method name=\"getOverallRemainingTime\">\n      <arg direction=\""
        "out\" type=\"i\"/>\n    </method>\n    <method name=\"clearAutoFoc"
        "usHFR\">\n      <arg direction=\"in\" type=\"s\" name=\"trainname\""
        "/>\n      <annotation value=\"true\" name=\"org.freedesktop.DBus.M"
        "ethod.NoReply\"/>\n    </method>\n    <method name=\"ignoreSequenc"
        "eHistory\">\n      <annotation value=\"true\" name=\"org.freedeskt"
        "op.DBus.Method.NoReply\"/>\n    </method>\n    <method name=\"setC"
        "apturedFramesMap\">\n      <arg direction=\"in\" type=\"s\" name=\""
        "signature\"/>\n      <arg direction=\"in\" type=\"i\" name=\"count"
        "\"/>\n      <arg direction=\"in\" type=\"s\" name=\"train\"/>\n   "
        "   <annotation value=\"true\" name=\"org.freedesktop.DBus.Method.N"
        "oReply\"/>\n    </method>\n    <method name=\"setPicturesDirectory"
        "\">\n      <arg direction=\"in\" type=\"s\" name=\"path\"/>\n     "
        " <arg direction=\"out\" type=\"b\"/>\n    </method>\n    <method n"
        "ame=\"getPicturesDirectory\">\n      <arg direction=\"out\" type=\""
        "s\"/>\n    </method>\n    <method name=\"mainCameraDeviceName\">\n"
        "      <arg direction=\"out\" type=\"s\"/>\n    </method>\n    <sig"
        "nal name=\"newLog\">\n      <arg direction=\"out\" type=\"s\" name"
        "=\"text\"/>\n    </signal>\n    <signal name=\"meridianFlipStarted"
        "\"/>\n    <signal name=\"newStatus\">\n      <arg direction=\"out\""
        " type=\"(i)\" name=\"status\"/>\n      <arg direction=\"out\" type"
        "=\"s\" name=\"trainname\"/>\n      <arg direction=\"out\" type=\"i"
        "\" name=\"cameraID\"/>\n      <annotation value=\"Ekos::CaptureSta"
        "te\" name=\"org.qtproject.QtDBus.QtTypeName.Out0\"/>\n    </signal"
        ">\n    <signal name=\"captureComplete\">\n      <arg direction=\"o"
        "ut\" type=\"a{sv}\" name=\"metadata\"/>\n      <arg direction=\"ou"
        "t\" type=\"s\" name=\"train\"/>\n      <annotation value=\"QVarian"
        "tMap\" name=\"org.qtproject.QtDBus.QtTypeName.In0\"/>\n      <anno"
        "tation value=\"QVariantMap\" name=\"org.qtproject.QtDBus.QtTypeNam"
        "e.Out0\"/>\n    </signal>\n    <signal name=\"ready\"/>\n  </inter"
        "face>\n",
        "captureComplete",
        "",
        "QVariantMap",
        "metadata",
        "train",
        "meridianFlipStarted",
        "newLog",
        "text",
        "newStatus",
        "Ekos::CaptureState",
        "status",
        "trainname",
        "cameraID",
        "ready",
        "abort",
        "Q_NOREPLY",
        "clearAutoFocusHFR",
        "clearSequenceQueue",
        "findCameraPosition",
        "addIfNecessary",
        "getActiveJobID",
        "getActiveJobRemainingTime",
        "getJobCount",
        "getJobExposureDuration",
        "id",
        "getJobExposureProgress",
        "getJobFilterName",
        "getJobFrameType",
        "getJobImageCount",
        "getJobImageProgress",
        "getJobPlaceholderFormat",
        "getJobPreviewFileName",
        "getJobState",
        "getOverallRemainingTime",
        "getPendingJobCount",
        "getPicturesDirectory",
        "getProgressPercentage",
        "getSequenceQueueStatus",
        "ignoreSequenceHistory",
        "loadSequenceQueue",
        "fileURL",
        "isMaster",
        "targetName",
        "mainCameraDeviceName",
        "pause",
        "restartCamera",
        "name",
        "saveSequenceQueue",
        "path",
        "setCapturedFramesMap",
        "signature",
        "count",
        "setInSequenceFocus",
        "enable",
        "HFR",
        "setMaximumGuidingDeviation",
        "value",
        "setPicturesDirectory",
        "start",
        "stop",
        "suspend",
        "toggleSequence",
        "toggleVideo",
        "enabled",
        "camera",
        "coolerControl",
        "filter",
        "filterWheel",
        "logText",
        "observerName",
        "opticalTrain"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'captureComplete'
        QtMocHelpers::SignalData<void(const QVariantMap &, const QString &)>(5, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 }, { QMetaType::QString, 9 },
        }}),
        // Signal 'meridianFlipStarted'
        QtMocHelpers::SignalData<void()>(10, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newLog'
        QtMocHelpers::SignalData<void(const QString &)>(11, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 12 },
        }}),
        // Signal 'newStatus'
        QtMocHelpers::SignalData<void(Ekos::CaptureState, const QString &, int)>(13, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 14, 15 }, { QMetaType::QString, 16 }, { QMetaType::Int, 17 },
        }}),
        // Signal 'ready'
        QtMocHelpers::SignalData<void()>(18, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'abort'
        QtMocHelpers::SlotData<void(const QString &)>(19, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'clearAutoFocusHFR'
        QtMocHelpers::SlotData<void(const QString &)>(21, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 },
        }}),
        // Slot 'clearSequenceQueue'
        QtMocHelpers::SlotData<void()>(22, 20, QMC::AccessPublic, QMetaType::Void),
        // Slot 'findCameraPosition'
        QtMocHelpers::SlotData<int(const QString &, bool)>(23, 6, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 9 }, { QMetaType::Bool, 24 },
        }}),
        // Slot 'getActiveJobID'
        QtMocHelpers::SlotData<int()>(25, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getActiveJobRemainingTime'
        QtMocHelpers::SlotData<int()>(26, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getJobCount'
        QtMocHelpers::SlotData<int()>(27, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getJobExposureDuration'
        QtMocHelpers::SlotData<double(int)>(28, 6, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getJobExposureProgress'
        QtMocHelpers::SlotData<double(int)>(30, 6, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getJobFilterName'
        QtMocHelpers::SlotData<QString(int)>(31, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getJobFrameType'
        QtMocHelpers::SlotData<int(int)>(32, 6, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getJobImageCount'
        QtMocHelpers::SlotData<int(int)>(33, 6, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getJobImageProgress'
        QtMocHelpers::SlotData<int(int)>(34, 6, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getJobPlaceholderFormat'
        QtMocHelpers::SlotData<QString()>(35, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getJobPreviewFileName'
        QtMocHelpers::SlotData<QString()>(36, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getJobState'
        QtMocHelpers::SlotData<QString(int)>(37, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 29 },
        }}),
        // Slot 'getOverallRemainingTime'
        QtMocHelpers::SlotData<int()>(38, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getPendingJobCount'
        QtMocHelpers::SlotData<int()>(39, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getPicturesDirectory'
        QtMocHelpers::SlotData<QString()>(40, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getProgressPercentage'
        QtMocHelpers::SlotData<double()>(41, 6, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getSequenceQueueStatus'
        QtMocHelpers::SlotData<QString()>(42, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'ignoreSequenceHistory'
        QtMocHelpers::SlotData<void()>(43, 20, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loadSequenceQueue'
        QtMocHelpers::SlotData<bool(const QString &, const QString &, bool, const QString &)>(44, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 45 }, { QMetaType::QString, 9 }, { QMetaType::Bool, 46 }, { QMetaType::QString, 47 },
        }}),
        // Slot 'mainCameraDeviceName'
        QtMocHelpers::SlotData<QString()>(48, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'pause'
        QtMocHelpers::SlotData<void()>(49, 20, QMC::AccessPublic, QMetaType::Void),
        // Slot 'restartCamera'
        QtMocHelpers::SlotData<void(const QString &)>(50, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 51 },
        }}),
        // Slot 'saveSequenceQueue'
        QtMocHelpers::SlotData<bool(const QString &)>(52, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 53 },
        }}),
        // Slot 'setCapturedFramesMap'
        QtMocHelpers::SlotData<void(const QString &, int, const QString &)>(54, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 55 }, { QMetaType::Int, 56 }, { QMetaType::QString, 9 },
        }}),
        // Slot 'setInSequenceFocus'
        QtMocHelpers::SlotData<void(bool, double)>(57, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 58 }, { QMetaType::Double, 59 },
        }}),
        // Slot 'setMaximumGuidingDeviation'
        QtMocHelpers::SlotData<void(bool, double)>(60, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 58 }, { QMetaType::Double, 61 },
        }}),
        // Slot 'setPicturesDirectory'
        QtMocHelpers::SlotData<bool(const QString &)>(62, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 53 },
        }}),
        // Slot 'start'
        QtMocHelpers::SlotData<QString(const QString &)>(63, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'stop'
        QtMocHelpers::SlotData<void()>(64, 20, QMC::AccessPublic, QMetaType::Void),
        // Slot 'suspend'
        QtMocHelpers::SlotData<void()>(65, 20, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleSequence'
        QtMocHelpers::SlotData<void()>(66, 20, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleVideo'
        QtMocHelpers::SlotData<void(bool)>(67, 20, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 68 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'camera'
        QtMocHelpers::PropertyData<QString>(69, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'coolerControl'
        QtMocHelpers::PropertyData<bool>(70, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'filter'
        QtMocHelpers::PropertyData<QString>(71, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'filterWheel'
        QtMocHelpers::PropertyData<QString>(72, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'logText'
        QtMocHelpers::PropertyData<QStringList>(73, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'observerName'
        QtMocHelpers::PropertyData<QString>(74, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'opticalTrain'
        QtMocHelpers::PropertyData<QString>(75, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'status'
        QtMocHelpers::PropertyData<int>(15, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'targetName'
        QtMocHelpers::PropertyData<QString>(47, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<CaptureAdaptor, qt_meta_tag_ZN14CaptureAdaptorE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject CaptureAdaptor::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractAdaptor::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14CaptureAdaptorE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14CaptureAdaptorE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14CaptureAdaptorE_t>.metaTypes,
    nullptr
} };

void CaptureAdaptor::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<CaptureAdaptor *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->captureComplete((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 1: _t->meridianFlipStarted(); break;
        case 2: _t->newLog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->newStatus((*reinterpret_cast<std::add_pointer_t<Ekos::CaptureState>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 4: _t->ready(); break;
        case 5: _t->abort((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->clearAutoFocusHFR((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->clearSequenceQueue(); break;
        case 8: { int _r = _t->findCameraPosition((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 9: { int _r = _t->getActiveJobID();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 10: { int _r = _t->getActiveJobRemainingTime();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 11: { int _r = _t->getJobCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 12: { double _r = _t->getJobExposureDuration((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 13: { double _r = _t->getJobExposureProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 14: { QString _r = _t->getJobFilterName((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 15: { int _r = _t->getJobFrameType((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 16: { int _r = _t->getJobImageCount((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 17: { int _r = _t->getJobImageProgress((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 18: { QString _r = _t->getJobPlaceholderFormat();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 19: { QString _r = _t->getJobPreviewFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 20: { QString _r = _t->getJobState((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 21: { int _r = _t->getOverallRemainingTime();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 22: { int _r = _t->getPendingJobCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 23: { QString _r = _t->getPicturesDirectory();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 24: { double _r = _t->getProgressPercentage();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 25: { QString _r = _t->getSequenceQueueStatus();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 26: _t->ignoreSequenceHistory(); break;
        case 27: { bool _r = _t->loadSequenceQueue((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 28: { QString _r = _t->mainCameraDeviceName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 29: _t->pause(); break;
        case 30: _t->restartCamera((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 31: { bool _r = _t->saveSequenceQueue((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 32: _t->setCapturedFramesMap((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 33: _t->setInSequenceFocus((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 34: _t->setMaximumGuidingDeviation((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 35: { bool _r = _t->setPicturesDirectory((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: { QString _r = _t->start((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 37: _t->stop(); break;
        case 38: _t->suspend(); break;
        case 39: _t->toggleSequence(); break;
        case 40: _t->toggleVideo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Ekos::CaptureState >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (CaptureAdaptor::*)(const QVariantMap & , const QString & )>(_a, &CaptureAdaptor::captureComplete, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureAdaptor::*)()>(_a, &CaptureAdaptor::meridianFlipStarted, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureAdaptor::*)(const QString & )>(_a, &CaptureAdaptor::newLog, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureAdaptor::*)(Ekos::CaptureState , const QString & , int )>(_a, &CaptureAdaptor::newStatus, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (CaptureAdaptor::*)()>(_a, &CaptureAdaptor::ready, 4))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->camera(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->coolerControl(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->filter(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->filterWheel(); break;
        case 4: *reinterpret_cast<QStringList*>(_v) = _t->logText(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->observerName(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->opticalTrain(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->status(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->targetName(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 1: _t->setCoolerControl(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setFilter(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setObserverName(*reinterpret_cast<QString*>(_v)); break;
        case 6: _t->setOpticalTrain(*reinterpret_cast<QString*>(_v)); break;
        case 8: _t->setTargetName(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

void *CaptureAdaptor::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14CaptureAdaptorE_t>.strings))
        return static_cast<void*>(this);
    return QDBusAbstractAdaptor::qt_metacast(_clname);
}

int CaptureAdaptor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractAdaptor::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 41)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 41;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 41)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 41;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    }
    return _id;
}

// SIGNAL 0
void CaptureAdaptor::captureComplete(const QVariantMap & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void CaptureAdaptor::meridianFlipStarted()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

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

// SIGNAL 3
void CaptureAdaptor::newStatus(Ekos::CaptureState _t1, const QString & _t2, int _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2, _t3);
}

// SIGNAL 4
void CaptureAdaptor::ready()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}
QT_WARNING_POP
