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

#include "../../../../../../stellarium/plugins/ArchaeoLines/src/ArchaeoLines.hpp"
#include <QtCore/qmetatype.h>
#include <QtCore/qplugin.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'ArchaeoLines.hpp' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN11ArchaeoLineE_t {};
} // unnamed namespace

template <> constexpr inline auto ArchaeoLine::qt_create_metaobjectdata<qt_meta_tag_ZN11ArchaeoLineE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ArchaeoLine",
        "colorChanged",
        "",
        "Vec3f",
        "c",
        "flagLabelChanged",
        "on",
        "definingAngleChanged",
        "angle",
        "setColor",
        "update",
        "deltaTime",
        "setFadeDuration",
        "duration",
        "setDisplayed",
        "displayed",
        "setFontSize",
        "newSize",
        "setFontSizeFromApp",
        "setDefiningAngle",
        "getDefiningAngle",
        "updateLabel",
        "setLabelVisible",
        "b",
        "isLabelVisible",
        "setLineType",
        "ArchaeoLine::Line",
        "line",
        "setLabel",
        "newLabel",
        "getLabel",
        "color",
        "flagLabel",
        "definingAngle",
        "Line",
        "CurrentPlanetNone",
        "CurrentPlanetMercury",
        "CurrentPlanetVenus",
        "CurrentPlanetMars",
        "CurrentPlanetJupiter",
        "CurrentPlanetSaturn",
        "Equinox",
        "Solstices",
        "Crossquarters",
        "MajorStandstill",
        "MinorStandstill",
        "PolarCircles",
        "ZenithPassage",
        "NadirPassage",
        "SelectedObject",
        "CurrentSun",
        "CurrentMoon",
        "CustomDeclination1",
        "CustomDeclination2",
        "SelectedObjectHourAngle",
        "SelectedObjectAzimuth",
        "GeographicLocation1",
        "GeographicLocation2",
        "CustomAzimuth1",
        "CustomAzimuth2",
        "CustomAltitude1",
        "CustomAltitude2"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'colorChanged'
        QtMocHelpers::SignalData<void(Vec3f)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'flagLabelChanged'
        QtMocHelpers::SignalData<void(bool)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 6 },
        }}),
        // Signal 'definingAngleChanged'
        QtMocHelpers::SignalData<void(double)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 8 },
        }}),
        // Slot 'setColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'update'
        QtMocHelpers::SlotData<void(const double)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 11 },
        }}),
        // Slot 'setFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 13 },
        }}),
        // Slot 'setDisplayed'
        QtMocHelpers::SlotData<void(const bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 15 },
        }}),
        // Slot 'setFontSize'
        QtMocHelpers::SlotData<void(const int)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'setFontSizeFromApp'
        QtMocHelpers::SlotData<void(const int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'setDefiningAngle'
        QtMocHelpers::SlotData<void(const double)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 8 },
        }}),
        // Slot 'getDefiningAngle'
        QtMocHelpers::SlotData<double() const>(20, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'updateLabel'
        QtMocHelpers::SlotData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setLabelVisible'
        QtMocHelpers::SlotData<void(const bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'isLabelVisible'
        QtMocHelpers::SlotData<bool() const>(24, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLineType'
        QtMocHelpers::SlotData<void(const ArchaeoLine::Line)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Slot 'setLabel'
        QtMocHelpers::SlotData<void(const QString &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 29 },
        }}),
        // Slot 'getLabel'
        QtMocHelpers::SlotData<QString() const>(30, 2, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'color'
        QtMocHelpers::PropertyData<Vec3f>(31, 0x80000000 | 3, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
        // property 'flagLabel'
        QtMocHelpers::PropertyData<bool>(32, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 1),
        // property 'definingAngle'
        QtMocHelpers::PropertyData<double>(33, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Line'
        QtMocHelpers::EnumData<enum Line>(34, 34, QMC::EnumFlags{}).add({
            {   35, Line::CurrentPlanetNone },
            {   36, Line::CurrentPlanetMercury },
            {   37, Line::CurrentPlanetVenus },
            {   38, Line::CurrentPlanetMars },
            {   39, Line::CurrentPlanetJupiter },
            {   40, Line::CurrentPlanetSaturn },
            {   41, Line::Equinox },
            {   42, Line::Solstices },
            {   43, Line::Crossquarters },
            {   44, Line::MajorStandstill },
            {   45, Line::MinorStandstill },
            {   46, Line::PolarCircles },
            {   47, Line::ZenithPassage },
            {   48, Line::NadirPassage },
            {   49, Line::SelectedObject },
            {   50, Line::CurrentSun },
            {   51, Line::CurrentMoon },
            {   52, Line::CustomDeclination1 },
            {   53, Line::CustomDeclination2 },
            {   54, Line::SelectedObjectHourAngle },
            {   55, Line::SelectedObjectAzimuth },
            {   56, Line::GeographicLocation1 },
            {   57, Line::GeographicLocation2 },
            {   58, Line::CustomAzimuth1 },
            {   59, Line::CustomAzimuth2 },
            {   60, Line::CustomAltitude1 },
            {   61, Line::CustomAltitude2 },
        }),
    };
    return QtMocHelpers::metaObjectData<ArchaeoLine, qt_meta_tag_ZN11ArchaeoLineE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ArchaeoLine::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ArchaeoLineE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ArchaeoLineE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11ArchaeoLineE_t>.metaTypes,
    nullptr
} };

void ArchaeoLine::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ArchaeoLine *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->colorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 1: _t->flagLabelChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->definingAngleChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 3: _t->setColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 4: _t->update((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 5: _t->setFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 6: _t->setDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->setFontSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->setFontSizeFromApp((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->setDefiningAngle((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 10: { double _r = _t->getDefiningAngle();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 11: _t->updateLabel(); break;
        case 12: _t->setLabelVisible((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: { bool _r = _t->isLabelVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 14: _t->setLineType((*reinterpret_cast<std::add_pointer_t<ArchaeoLine::Line>>(_a[1]))); break;
        case 15: _t->setLabel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 16: { QString _r = _t->getLabel();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            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< Vec3f >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLine::*)(Vec3f )>(_a, &ArchaeoLine::colorChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLine::*)(bool )>(_a, &ArchaeoLine::flagLabelChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLine::*)(double )>(_a, &ArchaeoLine::definingAngleChanged, 2))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Vec3f >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<Vec3f*>(_v) = _t->getColor(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isLabelVisible(); break;
        case 2: *reinterpret_cast<double*>(_v) = _t->getDefiningAngle(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 1: _t->setLabelVisible(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setDefiningAngle(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void ArchaeoLine::colorChanged(Vec3f _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void ArchaeoLine::flagLabelChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void ArchaeoLine::definingAngleChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN12ArchaeoLinesE_t {};
} // unnamed namespace

template <> constexpr inline auto ArchaeoLines::qt_create_metaobjectdata<qt_meta_tag_ZN12ArchaeoLinesE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ArchaeoLines",
        "archaeoLinesEnabledChanged",
        "",
        "on",
        "showEquinoxChanged",
        "showSolsticesChanged",
        "showCrossquartersChanged",
        "showMajorStandstillsChanged",
        "showMinorStandstillsChanged",
        "showPolarCirclesChanged",
        "showZenithPassageChanged",
        "showNadirPassageChanged",
        "showSelectedObjectChanged",
        "showSelectedObjectAzimuthChanged",
        "showSelectedObjectHourAngleChanged",
        "showCurrentSunChanged",
        "showCurrentMoonChanged",
        "showGeographicLocation1Changed",
        "showGeographicLocation2Changed",
        "geographicLocation1Changed",
        "geographicLocation2Changed",
        "showCustomAzimuth1Changed",
        "showCustomAzimuth2Changed",
        "customAzimuth1Changed",
        "az",
        "customAzimuth2Changed",
        "showCustomAltitude1Changed",
        "showCustomAltitude2Changed",
        "customAltitude1Changed",
        "customAltitude2Changed",
        "showCustomDeclination1Changed",
        "showCustomDeclination2Changed",
        "customDeclination1Changed",
        "dec",
        "customDeclination2Changed",
        "currentPlanetChanged",
        "ArchaeoLine::Line",
        "l",
        "geographicLocation1LabelChanged",
        "label",
        "geographicLocation2LabelChanged",
        "customAzimuth1LabelChanged",
        "customAzimuth2LabelChanged",
        "customAltitude1LabelChanged",
        "customAltitude2LabelChanged",
        "customDeclination1LabelChanged",
        "customDeclination2LabelChanged",
        "equinoxColorChanged",
        "Vec3f",
        "color",
        "solsticesColorChanged",
        "crossquartersColorChanged",
        "majorStandstillColorChanged",
        "minorStandstillColorChanged",
        "polarCirclesColorChanged",
        "zenithPassageColorChanged",
        "nadirPassageColorChanged",
        "selectedObjectColorChanged",
        "selectedObjectAzimuthColorChanged",
        "selectedObjectHourAngleColorChanged",
        "currentSunColorChanged",
        "currentMoonColorChanged",
        "currentPlanetColorChanged",
        "geographicLocation1ColorChanged",
        "geographicLocation2ColorChanged",
        "customAzimuth1ColorChanged",
        "customAzimuth2ColorChanged",
        "customAltitude1ColorChanged",
        "customAltitude2ColorChanged",
        "customDeclination1ColorChanged",
        "customDeclination2ColorChanged",
        "lineWidthChanged",
        "width",
        "enableArchaeoLines",
        "b",
        "isEnabled",
        "isEquinoxDisplayed",
        "isSolsticesDisplayed",
        "isCrossquartersDisplayed",
        "isMajorStandstillsDisplayed",
        "isMinorStandstillsDisplayed",
        "isPolarCirclesDisplayed",
        "isZenithPassageDisplayed",
        "isNadirPassageDisplayed",
        "isSelectedObjectDisplayed",
        "isSelectedObjectAzimuthDisplayed",
        "isSelectedObjectHourAngleDisplayed",
        "isCurrentSunDisplayed",
        "isCurrentMoonDisplayed",
        "whichCurrentPlanetDisplayed",
        "isGeographicLocation1Displayed",
        "isGeographicLocation2Displayed",
        "isCustomAzimuth1Displayed",
        "isCustomAzimuth2Displayed",
        "isCustomAltitude1Displayed",
        "isCustomAltitude2Displayed",
        "isCustomDeclination1Displayed",
        "isCustomDeclination2Displayed",
        "showEquinox",
        "showSolstices",
        "showCrossquarters",
        "showMajorStandstills",
        "showMinorStandstills",
        "showPolarCircles",
        "showZenithPassage",
        "showNadirPassage",
        "showSelectedObject",
        "showSelectedObjectAzimuth",
        "showSelectedObjectHourAngle",
        "showCurrentSun",
        "showCurrentMoon",
        "showCurrentPlanet",
        "showCurrentPlanetNamed",
        "planet",
        "showGeographicLocation1",
        "showGeographicLocation2",
        "setGeographicLocation1Longitude",
        "lng",
        "setGeographicLocation1Latitude",
        "lat",
        "setGeographicLocation2Longitude",
        "setGeographicLocation2Latitude",
        "setGeographicLocation1Label",
        "setGeographicLocation2Label",
        "getGeographicLocation1Label",
        "getGeographicLocation2Label",
        "getGeographicLocation1Longitude",
        "getGeographicLocation1Latitude",
        "getGeographicLocation2Longitude",
        "getGeographicLocation2Latitude",
        "showCustomAzimuth1",
        "showCustomAzimuth2",
        "setCustomAzimuth1",
        "getCustomAzimuth1",
        "setCustomAzimuth2",
        "getCustomAzimuth2",
        "setCustomAzimuth1Label",
        "setCustomAzimuth2Label",
        "getCustomAzimuth1Label",
        "getCustomAzimuth2Label",
        "showCustomAltitude1",
        "showCustomAltitude2",
        "setCustomAltitude1",
        "alt",
        "getCustomAltitude1",
        "setCustomAltitude2",
        "getCustomAltitude2",
        "setCustomAltitude1Label",
        "setCustomAltitude2Label",
        "getCustomAltitude1Label",
        "getCustomAltitude2Label",
        "showCustomDeclination1",
        "showCustomDeclination2",
        "setCustomDeclination1",
        "getCustomDeclination1",
        "setCustomDeclination2",
        "getCustomDeclination2",
        "setCustomDeclination1Label",
        "setCustomDeclination2Label",
        "getCustomDeclination1Label",
        "getCustomDeclination2Label",
        "getLineAngle",
        "whichLine",
        "getLineLabel",
        "getEquinoxColor",
        "getSolsticesColor",
        "getCrossquartersColor",
        "getMajorStandstillColor",
        "getMinorStandstillColor",
        "getPolarCirclesColor",
        "getZenithPassageColor",
        "getNadirPassageColor",
        "getSelectedObjectColor",
        "getSelectedObjectAzimuthColor",
        "getSelectedObjectHourAngleColor",
        "getCurrentSunColor",
        "getCurrentMoonColor",
        "getCurrentPlanetColor",
        "getGeographicLocation1Color",
        "getGeographicLocation2Color",
        "getCustomAzimuth1Color",
        "getCustomAzimuth2Color",
        "getCustomAltitude1Color",
        "getCustomAltitude2Color",
        "getCustomDeclination1Color",
        "getCustomDeclination2Color",
        "setEquinoxColor",
        "setSolsticesColor",
        "setCrossquartersColor",
        "setMajorStandstillColor",
        "setMinorStandstillColor",
        "setPolarCirclesColor",
        "setZenithPassageColor",
        "setNadirPassageColor",
        "setSelectedObjectColor",
        "setSelectedObjectAzimuthColor",
        "setSelectedObjectHourAngleColor",
        "setCurrentSunColor",
        "setCurrentMoonColor",
        "setCurrentPlanetColor",
        "setGeographicLocation1Color",
        "setGeographicLocation2Color",
        "setCustomAzimuth1Color",
        "setCustomAzimuth2Color",
        "setCustomAltitude1Color",
        "setCustomAltitude2Color",
        "setCustomDeclination1Color",
        "setCustomDeclination2Color",
        "getLineWidth",
        "setLineWidth",
        "updateObserverLocation",
        "StelLocation",
        "loc",
        "enabled",
        "flagShowEquinox",
        "flagShowSolstices",
        "flagShowCrossquarters",
        "flagShowMajorStandstills",
        "flagShowMinorStandstills",
        "flagShowPolarCircles",
        "flagShowZenithPassage",
        "flagShowNadirPassage",
        "flagShowSelectedObject",
        "flagShowSelectedObjectAzimuth",
        "flagShowSelectedObjectHourAngle",
        "flagShowCurrentSun",
        "flagShowCurrentMoon",
        "enumShowCurrentPlanet",
        "flagShowGeographicLocation1",
        "flagShowGeographicLocation2",
        "geographicLocation1Longitude",
        "geographicLocation1Latitude",
        "geographicLocation2Longitude",
        "geographicLocation2Latitude",
        "flagShowCustomAzimuth1",
        "flagShowCustomAzimuth2",
        "customAzimuth1",
        "customAzimuth2",
        "flagShowCustomAltitude1",
        "flagShowCustomAltitude2",
        "customAltitude1",
        "customAltitude2",
        "flagShowCustomDeclination1",
        "flagShowCustomDeclination2",
        "customDeclination1",
        "customDeclination2",
        "geographicLocation1Label",
        "geographicLocation2Label",
        "customAzimuth1Label",
        "customAzimuth2Label",
        "customAltitude1Label",
        "customAltitude2Label",
        "customDeclination1Label",
        "customDeclination2Label",
        "equinoxColor",
        "solsticesColor",
        "crossquartersColor",
        "majorStandstillColor",
        "minorStandstillColor",
        "polarCirclesColor",
        "zenithPassageColor",
        "nadirPassageColor",
        "selectedObjectColor",
        "selectedObjectAzimuthColor",
        "selectedObjectHourAngleColor",
        "currentSunColor",
        "currentMoonColor",
        "currentPlanetColor",
        "geographicLocation1Color",
        "geographicLocation2Color",
        "customAzimuth1Color",
        "customAzimuth2Color",
        "customAltitude1Color",
        "customAltitude2Color",
        "customDeclination1Color",
        "customDeclination2Color",
        "lineWidth"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'archaeoLinesEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showEquinoxChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showSolsticesChanged'
        QtMocHelpers::SignalData<void(bool)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showCrossquartersChanged'
        QtMocHelpers::SignalData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showMajorStandstillsChanged'
        QtMocHelpers::SignalData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showMinorStandstillsChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showPolarCirclesChanged'
        QtMocHelpers::SignalData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showZenithPassageChanged'
        QtMocHelpers::SignalData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showNadirPassageChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showSelectedObjectChanged'
        QtMocHelpers::SignalData<void(bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showSelectedObjectAzimuthChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showSelectedObjectHourAngleChanged'
        QtMocHelpers::SignalData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showCurrentSunChanged'
        QtMocHelpers::SignalData<void(bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showCurrentMoonChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showGeographicLocation1Changed'
        QtMocHelpers::SignalData<void(bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showGeographicLocation2Changed'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'geographicLocation1Changed'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'geographicLocation2Changed'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showCustomAzimuth1Changed'
        QtMocHelpers::SignalData<void(bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showCustomAzimuth2Changed'
        QtMocHelpers::SignalData<void(bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'customAzimuth1Changed'
        QtMocHelpers::SignalData<void(double)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Signal 'customAzimuth2Changed'
        QtMocHelpers::SignalData<void(double)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Signal 'showCustomAltitude1Changed'
        QtMocHelpers::SignalData<void(double)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Signal 'showCustomAltitude2Changed'
        QtMocHelpers::SignalData<void(double)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Signal 'customAltitude1Changed'
        QtMocHelpers::SignalData<void(double)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Signal 'customAltitude2Changed'
        QtMocHelpers::SignalData<void(double)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Signal 'showCustomDeclination1Changed'
        QtMocHelpers::SignalData<void(bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'showCustomDeclination2Changed'
        QtMocHelpers::SignalData<void(bool)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'customDeclination1Changed'
        QtMocHelpers::SignalData<void(double)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 33 },
        }}),
        // Signal 'customDeclination2Changed'
        QtMocHelpers::SignalData<void(double)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 33 },
        }}),
        // Signal 'currentPlanetChanged'
        QtMocHelpers::SignalData<void(ArchaeoLine::Line)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 36, 37 },
        }}),
        // Signal 'geographicLocation1LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'geographicLocation2LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'customAzimuth1LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'customAzimuth2LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'customAltitude1LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'customAltitude2LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'customDeclination1LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'customDeclination2LabelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'equinoxColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'solsticesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'crossquartersColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'majorStandstillColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'minorStandstillColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'polarCirclesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'zenithPassageColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'nadirPassageColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'selectedObjectColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'selectedObjectAzimuthColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'selectedObjectHourAngleColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'currentSunColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'currentMoonColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'currentPlanetColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'geographicLocation1ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'geographicLocation2ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'customAzimuth1ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'customAzimuth2ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'customAltitude1ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'customAltitude2ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'customDeclination1ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'customDeclination2ColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Signal 'lineWidthChanged'
        QtMocHelpers::SignalData<void(int)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 72 },
        }}),
        // Slot 'enableArchaeoLines'
        QtMocHelpers::SlotData<void(bool)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'isEnabled'
        QtMocHelpers::SlotData<bool() const>(75, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isEquinoxDisplayed'
        QtMocHelpers::SlotData<bool() const>(76, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isSolsticesDisplayed'
        QtMocHelpers::SlotData<bool() const>(77, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCrossquartersDisplayed'
        QtMocHelpers::SlotData<bool() const>(78, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isMajorStandstillsDisplayed'
        QtMocHelpers::SlotData<bool() const>(79, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isMinorStandstillsDisplayed'
        QtMocHelpers::SlotData<bool() const>(80, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isPolarCirclesDisplayed'
        QtMocHelpers::SlotData<bool() const>(81, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isZenithPassageDisplayed'
        QtMocHelpers::SlotData<bool() const>(82, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isNadirPassageDisplayed'
        QtMocHelpers::SlotData<bool() const>(83, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isSelectedObjectDisplayed'
        QtMocHelpers::SlotData<bool() const>(84, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isSelectedObjectAzimuthDisplayed'
        QtMocHelpers::SlotData<bool() const>(85, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isSelectedObjectHourAngleDisplayed'
        QtMocHelpers::SlotData<bool() const>(86, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCurrentSunDisplayed'
        QtMocHelpers::SlotData<bool() const>(87, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCurrentMoonDisplayed'
        QtMocHelpers::SlotData<bool() const>(88, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'whichCurrentPlanetDisplayed'
        QtMocHelpers::SlotData<ArchaeoLine::Line() const>(89, 2, QMC::AccessPublic, 0x80000000 | 36),
        // Slot 'isGeographicLocation1Displayed'
        QtMocHelpers::SlotData<bool() const>(90, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isGeographicLocation2Displayed'
        QtMocHelpers::SlotData<bool() const>(91, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCustomAzimuth1Displayed'
        QtMocHelpers::SlotData<bool() const>(92, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCustomAzimuth2Displayed'
        QtMocHelpers::SlotData<bool() const>(93, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCustomAltitude1Displayed'
        QtMocHelpers::SlotData<bool() const>(94, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCustomAltitude2Displayed'
        QtMocHelpers::SlotData<bool() const>(95, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCustomDeclination1Displayed'
        QtMocHelpers::SlotData<bool() const>(96, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isCustomDeclination2Displayed'
        QtMocHelpers::SlotData<bool() const>(97, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'showEquinox'
        QtMocHelpers::SlotData<void(bool)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showSolstices'
        QtMocHelpers::SlotData<void(bool)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCrossquarters'
        QtMocHelpers::SlotData<void(bool)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showMajorStandstills'
        QtMocHelpers::SlotData<void(bool)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showMinorStandstills'
        QtMocHelpers::SlotData<void(bool)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showPolarCircles'
        QtMocHelpers::SlotData<void(bool)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showZenithPassage'
        QtMocHelpers::SlotData<void(bool)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showNadirPassage'
        QtMocHelpers::SlotData<void(bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showSelectedObject'
        QtMocHelpers::SlotData<void(bool)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showSelectedObjectAzimuth'
        QtMocHelpers::SlotData<void(bool)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showSelectedObjectHourAngle'
        QtMocHelpers::SlotData<void(bool)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCurrentSun'
        QtMocHelpers::SlotData<void(bool)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCurrentMoon'
        QtMocHelpers::SlotData<void(bool)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCurrentPlanet'
        QtMocHelpers::SlotData<void(ArchaeoLine::Line)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 36, 37 },
        }}),
        // Slot 'showCurrentPlanetNamed'
        QtMocHelpers::SlotData<void(const QString &)>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 113 },
        }}),
        // Slot 'showGeographicLocation1'
        QtMocHelpers::SlotData<void(bool)>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showGeographicLocation2'
        QtMocHelpers::SlotData<void(bool)>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'setGeographicLocation1Longitude'
        QtMocHelpers::SlotData<void(double)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 117 },
        }}),
        // Slot 'setGeographicLocation1Latitude'
        QtMocHelpers::SlotData<void(double)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 119 },
        }}),
        // Slot 'setGeographicLocation2Longitude'
        QtMocHelpers::SlotData<void(double)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 117 },
        }}),
        // Slot 'setGeographicLocation2Latitude'
        QtMocHelpers::SlotData<void(double)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 119 },
        }}),
        // Slot 'setGeographicLocation1Label'
        QtMocHelpers::SlotData<void(const QString &)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'setGeographicLocation2Label'
        QtMocHelpers::SlotData<void(const QString &)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'getGeographicLocation1Label'
        QtMocHelpers::SlotData<QString() const>(124, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getGeographicLocation2Label'
        QtMocHelpers::SlotData<QString() const>(125, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getGeographicLocation1Longitude'
        QtMocHelpers::SlotData<double() const>(126, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getGeographicLocation1Latitude'
        QtMocHelpers::SlotData<double() const>(127, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getGeographicLocation2Longitude'
        QtMocHelpers::SlotData<double() const>(128, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getGeographicLocation2Latitude'
        QtMocHelpers::SlotData<double() const>(129, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'showCustomAzimuth1'
        QtMocHelpers::SlotData<void(bool)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCustomAzimuth2'
        QtMocHelpers::SlotData<void(bool)>(131, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'setCustomAzimuth1'
        QtMocHelpers::SlotData<void(double)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Slot 'getCustomAzimuth1'
        QtMocHelpers::SlotData<double() const>(133, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCustomAzimuth2'
        QtMocHelpers::SlotData<void(double)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 24 },
        }}),
        // Slot 'getCustomAzimuth2'
        QtMocHelpers::SlotData<double() const>(135, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCustomAzimuth1Label'
        QtMocHelpers::SlotData<void(const QString &)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'setCustomAzimuth2Label'
        QtMocHelpers::SlotData<void(const QString &)>(137, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'getCustomAzimuth1Label'
        QtMocHelpers::SlotData<QString() const>(138, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getCustomAzimuth2Label'
        QtMocHelpers::SlotData<QString() const>(139, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'showCustomAltitude1'
        QtMocHelpers::SlotData<void(bool)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCustomAltitude2'
        QtMocHelpers::SlotData<void(bool)>(141, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'setCustomAltitude1'
        QtMocHelpers::SlotData<void(double)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 143 },
        }}),
        // Slot 'getCustomAltitude1'
        QtMocHelpers::SlotData<double() const>(144, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCustomAltitude2'
        QtMocHelpers::SlotData<void(double)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 143 },
        }}),
        // Slot 'getCustomAltitude2'
        QtMocHelpers::SlotData<double() const>(146, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCustomAltitude1Label'
        QtMocHelpers::SlotData<void(const QString &)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'setCustomAltitude2Label'
        QtMocHelpers::SlotData<void(const QString &)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'getCustomAltitude1Label'
        QtMocHelpers::SlotData<QString() const>(149, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getCustomAltitude2Label'
        QtMocHelpers::SlotData<QString() const>(150, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'showCustomDeclination1'
        QtMocHelpers::SlotData<void(bool)>(151, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'showCustomDeclination2'
        QtMocHelpers::SlotData<void(bool)>(152, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 74 },
        }}),
        // Slot 'setCustomDeclination1'
        QtMocHelpers::SlotData<void(double)>(153, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 33 },
        }}),
        // Slot 'getCustomDeclination1'
        QtMocHelpers::SlotData<double() const>(154, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCustomDeclination2'
        QtMocHelpers::SlotData<void(double)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 33 },
        }}),
        // Slot 'getCustomDeclination2'
        QtMocHelpers::SlotData<double() const>(156, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCustomDeclination1Label'
        QtMocHelpers::SlotData<void(const QString &)>(157, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'setCustomDeclination2Label'
        QtMocHelpers::SlotData<void(const QString &)>(158, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'getCustomDeclination1Label'
        QtMocHelpers::SlotData<QString() const>(159, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getCustomDeclination2Label'
        QtMocHelpers::SlotData<QString() const>(160, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getLineAngle'
        QtMocHelpers::SlotData<double(ArchaeoLine::Line) const>(161, 2, QMC::AccessPublic, QMetaType::Double, {{
            { 0x80000000 | 36, 162 },
        }}),
        // Slot 'getLineLabel'
        QtMocHelpers::SlotData<QString(ArchaeoLine::Line) const>(163, 2, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 36, 162 },
        }}),
        // Slot 'getEquinoxColor'
        QtMocHelpers::SlotData<Vec3f() const>(164, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getSolsticesColor'
        QtMocHelpers::SlotData<Vec3f() const>(165, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCrossquartersColor'
        QtMocHelpers::SlotData<Vec3f() const>(166, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getMajorStandstillColor'
        QtMocHelpers::SlotData<Vec3f() const>(167, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getMinorStandstillColor'
        QtMocHelpers::SlotData<Vec3f() const>(168, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getPolarCirclesColor'
        QtMocHelpers::SlotData<Vec3f() const>(169, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getZenithPassageColor'
        QtMocHelpers::SlotData<Vec3f() const>(170, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getNadirPassageColor'
        QtMocHelpers::SlotData<Vec3f() const>(171, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getSelectedObjectColor'
        QtMocHelpers::SlotData<Vec3f() const>(172, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getSelectedObjectAzimuthColor'
        QtMocHelpers::SlotData<Vec3f() const>(173, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getSelectedObjectHourAngleColor'
        QtMocHelpers::SlotData<Vec3f() const>(174, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCurrentSunColor'
        QtMocHelpers::SlotData<Vec3f() const>(175, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCurrentMoonColor'
        QtMocHelpers::SlotData<Vec3f() const>(176, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCurrentPlanetColor'
        QtMocHelpers::SlotData<Vec3f() const>(177, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getGeographicLocation1Color'
        QtMocHelpers::SlotData<Vec3f() const>(178, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getGeographicLocation2Color'
        QtMocHelpers::SlotData<Vec3f() const>(179, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCustomAzimuth1Color'
        QtMocHelpers::SlotData<Vec3f() const>(180, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCustomAzimuth2Color'
        QtMocHelpers::SlotData<Vec3f() const>(181, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCustomAltitude1Color'
        QtMocHelpers::SlotData<Vec3f() const>(182, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCustomAltitude2Color'
        QtMocHelpers::SlotData<Vec3f() const>(183, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCustomDeclination1Color'
        QtMocHelpers::SlotData<Vec3f() const>(184, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'getCustomDeclination2Color'
        QtMocHelpers::SlotData<Vec3f() const>(185, 2, QMC::AccessPublic, 0x80000000 | 48),
        // Slot 'setEquinoxColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(186, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setSolsticesColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCrossquartersColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(188, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setMajorStandstillColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(189, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setMinorStandstillColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(190, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setPolarCirclesColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(191, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setZenithPassageColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(192, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setNadirPassageColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(193, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setSelectedObjectColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(194, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setSelectedObjectAzimuthColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(195, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setSelectedObjectHourAngleColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(196, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCurrentSunColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(197, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCurrentMoonColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(198, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCurrentPlanetColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(199, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setGeographicLocation1Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(200, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setGeographicLocation2Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(201, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCustomAzimuth1Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(202, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCustomAzimuth2Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(203, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCustomAltitude1Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(204, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCustomAltitude2Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(205, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCustomDeclination1Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(206, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'setCustomDeclination2Color'
        QtMocHelpers::SlotData<void(const Vec3f &)>(207, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'getLineWidth'
        QtMocHelpers::SlotData<int() const>(208, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLineWidth'
        QtMocHelpers::SlotData<void(int)>(209, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 72 },
        }}),
        // Slot 'updateObserverLocation'
        QtMocHelpers::SlotData<void(const StelLocation &)>(210, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 211, 212 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'enabled'
        QtMocHelpers::PropertyData<bool>(213, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'flagShowEquinox'
        QtMocHelpers::PropertyData<bool>(214, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 1),
        // property 'flagShowSolstices'
        QtMocHelpers::PropertyData<bool>(215, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 2),
        // property 'flagShowCrossquarters'
        QtMocHelpers::PropertyData<bool>(216, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 3),
        // property 'flagShowMajorStandstills'
        QtMocHelpers::PropertyData<bool>(217, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 4),
        // property 'flagShowMinorStandstills'
        QtMocHelpers::PropertyData<bool>(218, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 5),
        // property 'flagShowPolarCircles'
        QtMocHelpers::PropertyData<bool>(219, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 6),
        // property 'flagShowZenithPassage'
        QtMocHelpers::PropertyData<bool>(220, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 7),
        // property 'flagShowNadirPassage'
        QtMocHelpers::PropertyData<bool>(221, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 8),
        // property 'flagShowSelectedObject'
        QtMocHelpers::PropertyData<bool>(222, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 9),
        // property 'flagShowSelectedObjectAzimuth'
        QtMocHelpers::PropertyData<bool>(223, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 10),
        // property 'flagShowSelectedObjectHourAngle'
        QtMocHelpers::PropertyData<bool>(224, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 11),
        // property 'flagShowCurrentSun'
        QtMocHelpers::PropertyData<bool>(225, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'flagShowCurrentMoon'
        QtMocHelpers::PropertyData<bool>(226, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 13),
        // property 'enumShowCurrentPlanet'
        QtMocHelpers::PropertyData<ArchaeoLine::Line>(227, 0x80000000 | 36, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 30),
        // property 'flagShowGeographicLocation1'
        QtMocHelpers::PropertyData<bool>(228, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 14),
        // property 'flagShowGeographicLocation2'
        QtMocHelpers::PropertyData<bool>(229, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 15),
        // property 'geographicLocation1Longitude'
        QtMocHelpers::PropertyData<double>(230, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'geographicLocation1Latitude'
        QtMocHelpers::PropertyData<double>(231, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'geographicLocation2Longitude'
        QtMocHelpers::PropertyData<double>(232, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'geographicLocation2Latitude'
        QtMocHelpers::PropertyData<double>(233, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'flagShowCustomAzimuth1'
        QtMocHelpers::PropertyData<bool>(234, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 18),
        // property 'flagShowCustomAzimuth2'
        QtMocHelpers::PropertyData<bool>(235, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 19),
        // property 'customAzimuth1'
        QtMocHelpers::PropertyData<double>(236, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'customAzimuth2'
        QtMocHelpers::PropertyData<double>(237, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'flagShowCustomAltitude1'
        QtMocHelpers::PropertyData<bool>(238, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 22),
        // property 'flagShowCustomAltitude2'
        QtMocHelpers::PropertyData<bool>(239, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 23),
        // property 'customAltitude1'
        QtMocHelpers::PropertyData<double>(240, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'customAltitude2'
        QtMocHelpers::PropertyData<double>(241, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'flagShowCustomDeclination1'
        QtMocHelpers::PropertyData<bool>(242, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 26),
        // property 'flagShowCustomDeclination2'
        QtMocHelpers::PropertyData<bool>(243, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 27),
        // property 'customDeclination1'
        QtMocHelpers::PropertyData<double>(244, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'customDeclination2'
        QtMocHelpers::PropertyData<double>(245, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'geographicLocation1Label'
        QtMocHelpers::PropertyData<QString>(246, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 31),
        // property 'geographicLocation2Label'
        QtMocHelpers::PropertyData<QString>(247, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 32),
        // property 'customAzimuth1Label'
        QtMocHelpers::PropertyData<QString>(248, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 33),
        // property 'customAzimuth2Label'
        QtMocHelpers::PropertyData<QString>(249, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 34),
        // property 'customAltitude1Label'
        QtMocHelpers::PropertyData<QString>(250, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 35),
        // property 'customAltitude2Label'
        QtMocHelpers::PropertyData<QString>(251, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 36),
        // property 'customDeclination1Label'
        QtMocHelpers::PropertyData<QString>(252, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 37),
        // property 'customDeclination2Label'
        QtMocHelpers::PropertyData<QString>(253, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 38),
        // property 'equinoxColor'
        QtMocHelpers::PropertyData<Vec3f>(254, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 39),
        // property 'solsticesColor'
        QtMocHelpers::PropertyData<Vec3f>(255, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 40),
        // property 'crossquartersColor'
        QtMocHelpers::PropertyData<Vec3f>(256, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 41),
        // property 'majorStandstillColor'
        QtMocHelpers::PropertyData<Vec3f>(257, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 42),
        // property 'minorStandstillColor'
        QtMocHelpers::PropertyData<Vec3f>(258, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 43),
        // property 'polarCirclesColor'
        QtMocHelpers::PropertyData<Vec3f>(259, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 44),
        // property 'zenithPassageColor'
        QtMocHelpers::PropertyData<Vec3f>(260, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 45),
        // property 'nadirPassageColor'
        QtMocHelpers::PropertyData<Vec3f>(261, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 46),
        // property 'selectedObjectColor'
        QtMocHelpers::PropertyData<Vec3f>(262, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 47),
        // property 'selectedObjectAzimuthColor'
        QtMocHelpers::PropertyData<Vec3f>(263, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 48),
        // property 'selectedObjectHourAngleColor'
        QtMocHelpers::PropertyData<Vec3f>(264, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 49),
        // property 'currentSunColor'
        QtMocHelpers::PropertyData<Vec3f>(265, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 50),
        // property 'currentMoonColor'
        QtMocHelpers::PropertyData<Vec3f>(266, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 51),
        // property 'currentPlanetColor'
        QtMocHelpers::PropertyData<Vec3f>(267, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 52),
        // property 'geographicLocation1Color'
        QtMocHelpers::PropertyData<Vec3f>(268, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 53),
        // property 'geographicLocation2Color'
        QtMocHelpers::PropertyData<Vec3f>(269, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 54),
        // property 'customAzimuth1Color'
        QtMocHelpers::PropertyData<Vec3f>(270, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 55),
        // property 'customAzimuth2Color'
        QtMocHelpers::PropertyData<Vec3f>(271, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 56),
        // property 'customAltitude1Color'
        QtMocHelpers::PropertyData<Vec3f>(272, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 57),
        // property 'customAltitude2Color'
        QtMocHelpers::PropertyData<Vec3f>(273, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 58),
        // property 'customDeclination1Color'
        QtMocHelpers::PropertyData<Vec3f>(274, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 59),
        // property 'customDeclination2Color'
        QtMocHelpers::PropertyData<Vec3f>(275, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 60),
        // property 'lineWidth'
        QtMocHelpers::PropertyData<int>(276, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 61),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ArchaeoLines, qt_meta_tag_ZN12ArchaeoLinesE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN12ArchaeoLinesE[] = {
    QMetaObject::SuperData::link<ArchaeoLine::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject ArchaeoLines::staticMetaObject = { {
    QMetaObject::SuperData::link<StelModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ArchaeoLinesE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ArchaeoLinesE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN12ArchaeoLinesE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12ArchaeoLinesE_t>.metaTypes,
    nullptr
} };

void ArchaeoLines::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ArchaeoLines *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->archaeoLinesEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->showEquinoxChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->showSolsticesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->showCrossquartersChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->showMajorStandstillsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->showMinorStandstillsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->showPolarCirclesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->showZenithPassageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->showNadirPassageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->showSelectedObjectChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->showSelectedObjectAzimuthChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->showSelectedObjectHourAngleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->showCurrentSunChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->showCurrentMoonChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->showGeographicLocation1Changed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->showGeographicLocation2Changed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->geographicLocation1Changed(); break;
        case 17: _t->geographicLocation2Changed(); break;
        case 18: _t->showCustomAzimuth1Changed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->showCustomAzimuth2Changed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->customAzimuth1Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 21: _t->customAzimuth2Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 22: _t->showCustomAltitude1Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 23: _t->showCustomAltitude2Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 24: _t->customAltitude1Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 25: _t->customAltitude2Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 26: _t->showCustomDeclination1Changed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->showCustomDeclination2Changed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 28: _t->customDeclination1Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 29: _t->customDeclination2Changed((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 30: _t->currentPlanetChanged((*reinterpret_cast<std::add_pointer_t<ArchaeoLine::Line>>(_a[1]))); break;
        case 31: _t->geographicLocation1LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 32: _t->geographicLocation2LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 33: _t->customAzimuth1LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 34: _t->customAzimuth2LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 35: _t->customAltitude1LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 36: _t->customAltitude2LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 37: _t->customDeclination1LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 38: _t->customDeclination2LabelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 39: _t->equinoxColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 40: _t->solsticesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 41: _t->crossquartersColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 42: _t->majorStandstillColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 43: _t->minorStandstillColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 44: _t->polarCirclesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 45: _t->zenithPassageColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 46: _t->nadirPassageColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 47: _t->selectedObjectColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 48: _t->selectedObjectAzimuthColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 49: _t->selectedObjectHourAngleColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 50: _t->currentSunColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 51: _t->currentMoonColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 52: _t->currentPlanetColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 53: _t->geographicLocation1ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 54: _t->geographicLocation2ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 55: _t->customAzimuth1ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 56: _t->customAzimuth2ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 57: _t->customAltitude1ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 58: _t->customAltitude2ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 59: _t->customDeclination1ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 60: _t->customDeclination2ColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 61: _t->lineWidthChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 62: _t->enableArchaeoLines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 63: { bool _r = _t->isEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 64: { bool _r = _t->isEquinoxDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 65: { bool _r = _t->isSolsticesDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 66: { bool _r = _t->isCrossquartersDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 67: { bool _r = _t->isMajorStandstillsDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 68: { bool _r = _t->isMinorStandstillsDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 69: { bool _r = _t->isPolarCirclesDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: { bool _r = _t->isZenithPassageDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 71: { bool _r = _t->isNadirPassageDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 72: { bool _r = _t->isSelectedObjectDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 73: { bool _r = _t->isSelectedObjectAzimuthDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 74: { bool _r = _t->isSelectedObjectHourAngleDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 75: { bool _r = _t->isCurrentSunDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 76: { bool _r = _t->isCurrentMoonDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 77: { ArchaeoLine::Line _r = _t->whichCurrentPlanetDisplayed();
            if (_a[0]) *reinterpret_cast<ArchaeoLine::Line*>(_a[0]) = std::move(_r); }  break;
        case 78: { bool _r = _t->isGeographicLocation1Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 79: { bool _r = _t->isGeographicLocation2Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 80: { bool _r = _t->isCustomAzimuth1Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 81: { bool _r = _t->isCustomAzimuth2Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 82: { bool _r = _t->isCustomAltitude1Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 83: { bool _r = _t->isCustomAltitude2Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 84: { bool _r = _t->isCustomDeclination1Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 85: { bool _r = _t->isCustomDeclination2Displayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 86: _t->showEquinox((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 87: _t->showSolstices((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 88: _t->showCrossquarters((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 89: _t->showMajorStandstills((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 90: _t->showMinorStandstills((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 91: _t->showPolarCircles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 92: _t->showZenithPassage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 93: _t->showNadirPassage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 94: _t->showSelectedObject((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 95: _t->showSelectedObjectAzimuth((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 96: _t->showSelectedObjectHourAngle((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 97: _t->showCurrentSun((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 98: _t->showCurrentMoon((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 99: _t->showCurrentPlanet((*reinterpret_cast<std::add_pointer_t<ArchaeoLine::Line>>(_a[1]))); break;
        case 100: _t->showCurrentPlanetNamed((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 101: _t->showGeographicLocation1((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 102: _t->showGeographicLocation2((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 103: _t->setGeographicLocation1Longitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 104: _t->setGeographicLocation1Latitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 105: _t->setGeographicLocation2Longitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 106: _t->setGeographicLocation2Latitude((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 107: _t->setGeographicLocation1Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 108: _t->setGeographicLocation2Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 109: { QString _r = _t->getGeographicLocation1Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 110: { QString _r = _t->getGeographicLocation2Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 111: { double _r = _t->getGeographicLocation1Longitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 112: { double _r = _t->getGeographicLocation1Latitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 113: { double _r = _t->getGeographicLocation2Longitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 114: { double _r = _t->getGeographicLocation2Latitude();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 115: _t->showCustomAzimuth1((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 116: _t->showCustomAzimuth2((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 117: _t->setCustomAzimuth1((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 118: { double _r = _t->getCustomAzimuth1();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 119: _t->setCustomAzimuth2((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 120: { double _r = _t->getCustomAzimuth2();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 121: _t->setCustomAzimuth1Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 122: _t->setCustomAzimuth2Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 123: { QString _r = _t->getCustomAzimuth1Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 124: { QString _r = _t->getCustomAzimuth2Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 125: _t->showCustomAltitude1((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 126: _t->showCustomAltitude2((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 127: _t->setCustomAltitude1((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 128: { double _r = _t->getCustomAltitude1();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 129: _t->setCustomAltitude2((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 130: { double _r = _t->getCustomAltitude2();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 131: _t->setCustomAltitude1Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 132: _t->setCustomAltitude2Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 133: { QString _r = _t->getCustomAltitude1Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 134: { QString _r = _t->getCustomAltitude2Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 135: _t->showCustomDeclination1((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 136: _t->showCustomDeclination2((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 137: _t->setCustomDeclination1((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 138: { double _r = _t->getCustomDeclination1();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 139: _t->setCustomDeclination2((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 140: { double _r = _t->getCustomDeclination2();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 141: _t->setCustomDeclination1Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 142: _t->setCustomDeclination2Label((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 143: { QString _r = _t->getCustomDeclination1Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 144: { QString _r = _t->getCustomDeclination2Label();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 145: { double _r = _t->getLineAngle((*reinterpret_cast<std::add_pointer_t<ArchaeoLine::Line>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 146: { QString _r = _t->getLineLabel((*reinterpret_cast<std::add_pointer_t<ArchaeoLine::Line>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 147: { Vec3f _r = _t->getEquinoxColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 148: { Vec3f _r = _t->getSolsticesColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 149: { Vec3f _r = _t->getCrossquartersColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 150: { Vec3f _r = _t->getMajorStandstillColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 151: { Vec3f _r = _t->getMinorStandstillColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 152: { Vec3f _r = _t->getPolarCirclesColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 153: { Vec3f _r = _t->getZenithPassageColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 154: { Vec3f _r = _t->getNadirPassageColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 155: { Vec3f _r = _t->getSelectedObjectColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 156: { Vec3f _r = _t->getSelectedObjectAzimuthColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 157: { Vec3f _r = _t->getSelectedObjectHourAngleColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 158: { Vec3f _r = _t->getCurrentSunColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 159: { Vec3f _r = _t->getCurrentMoonColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 160: { Vec3f _r = _t->getCurrentPlanetColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 161: { Vec3f _r = _t->getGeographicLocation1Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 162: { Vec3f _r = _t->getGeographicLocation2Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 163: { Vec3f _r = _t->getCustomAzimuth1Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 164: { Vec3f _r = _t->getCustomAzimuth2Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 165: { Vec3f _r = _t->getCustomAltitude1Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 166: { Vec3f _r = _t->getCustomAltitude2Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 167: { Vec3f _r = _t->getCustomDeclination1Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 168: { Vec3f _r = _t->getCustomDeclination2Color();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 169: _t->setEquinoxColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 170: _t->setSolsticesColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 171: _t->setCrossquartersColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 172: _t->setMajorStandstillColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 173: _t->setMinorStandstillColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 174: _t->setPolarCirclesColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 175: _t->setZenithPassageColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 176: _t->setNadirPassageColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 177: _t->setSelectedObjectColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 178: _t->setSelectedObjectAzimuthColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 179: _t->setSelectedObjectHourAngleColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 180: _t->setCurrentSunColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 181: _t->setCurrentMoonColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 182: _t->setCurrentPlanetColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 183: _t->setGeographicLocation1Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 184: _t->setGeographicLocation2Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 185: _t->setCustomAzimuth1Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 186: _t->setCustomAzimuth2Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 187: _t->setCustomAltitude1Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 188: _t->setCustomAltitude2Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 189: _t->setCustomDeclination1Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 190: _t->setCustomDeclination2Color((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 191: { int _r = _t->getLineWidth();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 192: _t->setLineWidth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 193: _t->updateObserverLocation((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); 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< Vec3f >(); 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< Vec3f >(); break;
            }
            break;
        case 41:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); 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< Vec3f >(); break;
            }
            break;
        case 43:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); 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< Vec3f >(); 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< Vec3f >(); 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< Vec3f >(); break;
            }
            break;
        case 47:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); 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< Vec3f >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 50:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 51:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 52:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 53:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 54:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 55:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 56:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 57:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 58:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 59:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 60:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 169:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 170:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 171:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 172:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 173:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 174:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 175:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 176:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 177:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 178:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 179:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 180:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 181:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 182:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 183:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 184:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 185:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 186:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 187:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 188:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 189:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 190:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 193:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::archaeoLinesEnabledChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showEquinoxChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showSolsticesChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCrossquartersChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showMajorStandstillsChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showMinorStandstillsChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showPolarCirclesChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showZenithPassageChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showNadirPassageChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showSelectedObjectChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showSelectedObjectAzimuthChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showSelectedObjectHourAngleChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCurrentSunChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCurrentMoonChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showGeographicLocation1Changed, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showGeographicLocation2Changed, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)()>(_a, &ArchaeoLines::geographicLocation1Changed, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)()>(_a, &ArchaeoLines::geographicLocation2Changed, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCustomAzimuth1Changed, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCustomAzimuth2Changed, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::customAzimuth1Changed, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::customAzimuth2Changed, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::showCustomAltitude1Changed, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::showCustomAltitude2Changed, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::customAltitude1Changed, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::customAltitude2Changed, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCustomDeclination1Changed, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(bool )>(_a, &ArchaeoLines::showCustomDeclination2Changed, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::customDeclination1Changed, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(double )>(_a, &ArchaeoLines::customDeclination2Changed, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(ArchaeoLine::Line )>(_a, &ArchaeoLines::currentPlanetChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::geographicLocation1LabelChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::geographicLocation2LabelChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::customAzimuth1LabelChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::customAzimuth2LabelChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::customAltitude1LabelChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::customAltitude2LabelChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::customDeclination1LabelChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const QString & )>(_a, &ArchaeoLines::customDeclination2LabelChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::equinoxColorChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::solsticesColorChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::crossquartersColorChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::majorStandstillColorChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::minorStandstillColorChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::polarCirclesColorChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::zenithPassageColorChanged, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::nadirPassageColorChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::selectedObjectColorChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::selectedObjectAzimuthColorChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::selectedObjectHourAngleColorChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::currentSunColorChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::currentMoonColorChanged, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::currentPlanetColorChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::geographicLocation1ColorChanged, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::geographicLocation2ColorChanged, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::customAzimuth1ColorChanged, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::customAzimuth2ColorChanged, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::customAltitude1ColorChanged, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::customAltitude2ColorChanged, 58))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::customDeclination1ColorChanged, 59))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(const Vec3f & )>(_a, &ArchaeoLines::customDeclination2ColorChanged, 60))
            return;
        if (QtMocHelpers::indexOfMethod<void (ArchaeoLines::*)(int )>(_a, &ArchaeoLines::lineWidthChanged, 61))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 62:
        case 61:
        case 60:
        case 59:
        case 58:
        case 57:
        case 56:
        case 55:
        case 54:
        case 53:
        case 52:
        case 51:
        case 50:
        case 49:
        case 48:
        case 47:
        case 46:
        case 45:
        case 44:
        case 43:
        case 42:
        case 41:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Vec3f >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isEnabled(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isEquinoxDisplayed(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->isSolsticesDisplayed(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->isCrossquartersDisplayed(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isMajorStandstillsDisplayed(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isMinorStandstillsDisplayed(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->isPolarCirclesDisplayed(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->isZenithPassageDisplayed(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->isNadirPassageDisplayed(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->isSelectedObjectDisplayed(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isSelectedObjectAzimuthDisplayed(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->isSelectedObjectHourAngleDisplayed(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->isCurrentSunDisplayed(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->isCurrentMoonDisplayed(); break;
        case 14: *reinterpret_cast<ArchaeoLine::Line*>(_v) = _t->whichCurrentPlanetDisplayed(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->isGeographicLocation1Displayed(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->isGeographicLocation2Displayed(); break;
        case 17: *reinterpret_cast<double*>(_v) = _t->getGeographicLocation1Longitude(); break;
        case 18: *reinterpret_cast<double*>(_v) = _t->getGeographicLocation1Latitude(); break;
        case 19: *reinterpret_cast<double*>(_v) = _t->getGeographicLocation2Longitude(); break;
        case 20: *reinterpret_cast<double*>(_v) = _t->getGeographicLocation2Latitude(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->isCustomAzimuth1Displayed(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->isCustomAzimuth2Displayed(); break;
        case 23: *reinterpret_cast<double*>(_v) = _t->getCustomAzimuth1(); break;
        case 24: *reinterpret_cast<double*>(_v) = _t->getCustomAzimuth2(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->isCustomAltitude1Displayed(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->isCustomAltitude2Displayed(); break;
        case 27: *reinterpret_cast<double*>(_v) = _t->getCustomAltitude1(); break;
        case 28: *reinterpret_cast<double*>(_v) = _t->getCustomAltitude2(); break;
        case 29: *reinterpret_cast<bool*>(_v) = _t->isCustomDeclination1Displayed(); break;
        case 30: *reinterpret_cast<bool*>(_v) = _t->isCustomDeclination2Displayed(); break;
        case 31: *reinterpret_cast<double*>(_v) = _t->getCustomDeclination1(); break;
        case 32: *reinterpret_cast<double*>(_v) = _t->getCustomDeclination2(); break;
        case 33: *reinterpret_cast<QString*>(_v) = _t->getGeographicLocation1Label(); break;
        case 34: *reinterpret_cast<QString*>(_v) = _t->getGeographicLocation2Label(); break;
        case 35: *reinterpret_cast<QString*>(_v) = _t->getCustomAzimuth1Label(); break;
        case 36: *reinterpret_cast<QString*>(_v) = _t->getCustomAzimuth2Label(); break;
        case 37: *reinterpret_cast<QString*>(_v) = _t->getCustomAltitude1Label(); break;
        case 38: *reinterpret_cast<QString*>(_v) = _t->getCustomAltitude2Label(); break;
        case 39: *reinterpret_cast<QString*>(_v) = _t->getCustomDeclination1Label(); break;
        case 40: *reinterpret_cast<QString*>(_v) = _t->getCustomDeclination2Label(); break;
        case 41: *reinterpret_cast<Vec3f*>(_v) = _t->getEquinoxColor(); break;
        case 42: *reinterpret_cast<Vec3f*>(_v) = _t->getSolsticesColor(); break;
        case 43: *reinterpret_cast<Vec3f*>(_v) = _t->getCrossquartersColor(); break;
        case 44: *reinterpret_cast<Vec3f*>(_v) = _t->getMajorStandstillColor(); break;
        case 45: *reinterpret_cast<Vec3f*>(_v) = _t->getMinorStandstillColor(); break;
        case 46: *reinterpret_cast<Vec3f*>(_v) = _t->getPolarCirclesColor(); break;
        case 47: *reinterpret_cast<Vec3f*>(_v) = _t->getZenithPassageColor(); break;
        case 48: *reinterpret_cast<Vec3f*>(_v) = _t->getNadirPassageColor(); break;
        case 49: *reinterpret_cast<Vec3f*>(_v) = _t->getSelectedObjectColor(); break;
        case 50: *reinterpret_cast<Vec3f*>(_v) = _t->getSelectedObjectAzimuthColor(); break;
        case 51: *reinterpret_cast<Vec3f*>(_v) = _t->getSelectedObjectHourAngleColor(); break;
        case 52: *reinterpret_cast<Vec3f*>(_v) = _t->getCurrentSunColor(); break;
        case 53: *reinterpret_cast<Vec3f*>(_v) = _t->getCurrentMoonColor(); break;
        case 54: *reinterpret_cast<Vec3f*>(_v) = _t->getCurrentPlanetColor(); break;
        case 55: *reinterpret_cast<Vec3f*>(_v) = _t->getGeographicLocation1Color(); break;
        case 56: *reinterpret_cast<Vec3f*>(_v) = _t->getGeographicLocation2Color(); break;
        case 57: *reinterpret_cast<Vec3f*>(_v) = _t->getCustomAzimuth1Color(); break;
        case 58: *reinterpret_cast<Vec3f*>(_v) = _t->getCustomAzimuth2Color(); break;
        case 59: *reinterpret_cast<Vec3f*>(_v) = _t->getCustomAltitude1Color(); break;
        case 60: *reinterpret_cast<Vec3f*>(_v) = _t->getCustomAltitude2Color(); break;
        case 61: *reinterpret_cast<Vec3f*>(_v) = _t->getCustomDeclination1Color(); break;
        case 62: *reinterpret_cast<Vec3f*>(_v) = _t->getCustomDeclination2Color(); break;
        case 63: *reinterpret_cast<int*>(_v) = _t->getLineWidth(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->enableArchaeoLines(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->showEquinox(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->showSolstices(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->showCrossquarters(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->showMajorStandstills(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->showMinorStandstills(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->showPolarCircles(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->showZenithPassage(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->showNadirPassage(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->showSelectedObject(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->showSelectedObjectAzimuth(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->showSelectedObjectHourAngle(*reinterpret_cast<bool*>(_v)); break;
        case 12: _t->showCurrentSun(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->showCurrentMoon(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->showCurrentPlanet(*reinterpret_cast<ArchaeoLine::Line*>(_v)); break;
        case 15: _t->showGeographicLocation1(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->showGeographicLocation2(*reinterpret_cast<bool*>(_v)); break;
        case 17: _t->setGeographicLocation1Longitude(*reinterpret_cast<double*>(_v)); break;
        case 18: _t->setGeographicLocation1Latitude(*reinterpret_cast<double*>(_v)); break;
        case 19: _t->setGeographicLocation2Longitude(*reinterpret_cast<double*>(_v)); break;
        case 20: _t->setGeographicLocation2Latitude(*reinterpret_cast<double*>(_v)); break;
        case 21: _t->showCustomAzimuth1(*reinterpret_cast<bool*>(_v)); break;
        case 22: _t->showCustomAzimuth2(*reinterpret_cast<bool*>(_v)); break;
        case 23: _t->setCustomAzimuth1(*reinterpret_cast<double*>(_v)); break;
        case 24: _t->setCustomAzimuth2(*reinterpret_cast<double*>(_v)); break;
        case 25: _t->showCustomAltitude1(*reinterpret_cast<bool*>(_v)); break;
        case 26: _t->showCustomAltitude2(*reinterpret_cast<bool*>(_v)); break;
        case 27: _t->setCustomAltitude1(*reinterpret_cast<double*>(_v)); break;
        case 28: _t->setCustomAltitude2(*reinterpret_cast<double*>(_v)); break;
        case 29: _t->showCustomDeclination1(*reinterpret_cast<bool*>(_v)); break;
        case 30: _t->showCustomDeclination2(*reinterpret_cast<bool*>(_v)); break;
        case 31: _t->setCustomDeclination1(*reinterpret_cast<double*>(_v)); break;
        case 32: _t->setCustomDeclination2(*reinterpret_cast<double*>(_v)); break;
        case 33: _t->setGeographicLocation1Label(*reinterpret_cast<QString*>(_v)); break;
        case 34: _t->setGeographicLocation2Label(*reinterpret_cast<QString*>(_v)); break;
        case 35: _t->setCustomAzimuth1Label(*reinterpret_cast<QString*>(_v)); break;
        case 36: _t->setCustomAzimuth2Label(*reinterpret_cast<QString*>(_v)); break;
        case 37: _t->setCustomAltitude1Label(*reinterpret_cast<QString*>(_v)); break;
        case 38: _t->setCustomAltitude2Label(*reinterpret_cast<QString*>(_v)); break;
        case 39: _t->setCustomDeclination1Label(*reinterpret_cast<QString*>(_v)); break;
        case 40: _t->setCustomDeclination2Label(*reinterpret_cast<QString*>(_v)); break;
        case 41: _t->setEquinoxColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 42: _t->setSolsticesColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 43: _t->setCrossquartersColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 44: _t->setMajorStandstillColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 45: _t->setMinorStandstillColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 46: _t->setPolarCirclesColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 47: _t->setZenithPassageColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 48: _t->setNadirPassageColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 49: _t->setSelectedObjectColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 50: _t->setSelectedObjectAzimuthColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 51: _t->setSelectedObjectHourAngleColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 52: _t->setCurrentSunColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 53: _t->setCurrentMoonColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 54: _t->setCurrentPlanetColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 55: _t->setGeographicLocation1Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 56: _t->setGeographicLocation2Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 57: _t->setCustomAzimuth1Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 58: _t->setCustomAzimuth2Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 59: _t->setCustomAltitude1Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 60: _t->setCustomAltitude2Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 61: _t->setCustomDeclination1Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 62: _t->setCustomDeclination2Color(*reinterpret_cast<Vec3f*>(_v)); break;
        case 63: _t->setLineWidth(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void ArchaeoLines::archaeoLinesEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void ArchaeoLines::showEquinoxChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void ArchaeoLines::showSolsticesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void ArchaeoLines::showCrossquartersChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void ArchaeoLines::showMajorStandstillsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void ArchaeoLines::showMinorStandstillsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void ArchaeoLines::showPolarCirclesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void ArchaeoLines::showZenithPassageChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void ArchaeoLines::showNadirPassageChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void ArchaeoLines::showSelectedObjectChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void ArchaeoLines::showSelectedObjectAzimuthChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void ArchaeoLines::showSelectedObjectHourAngleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void ArchaeoLines::showCurrentSunChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void ArchaeoLines::showCurrentMoonChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void ArchaeoLines::showGeographicLocation1Changed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void ArchaeoLines::showGeographicLocation2Changed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void ArchaeoLines::geographicLocation1Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void ArchaeoLines::geographicLocation2Changed()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void ArchaeoLines::showCustomAzimuth1Changed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void ArchaeoLines::showCustomAzimuth2Changed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void ArchaeoLines::customAzimuth1Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void ArchaeoLines::customAzimuth2Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void ArchaeoLines::showCustomAltitude1Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void ArchaeoLines::showCustomAltitude2Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void ArchaeoLines::customAltitude1Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void ArchaeoLines::customAltitude2Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void ArchaeoLines::showCustomDeclination1Changed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void ArchaeoLines::showCustomDeclination2Changed(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void ArchaeoLines::customDeclination1Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void ArchaeoLines::customDeclination2Changed(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void ArchaeoLines::currentPlanetChanged(ArchaeoLine::Line _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void ArchaeoLines::geographicLocation1LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void ArchaeoLines::geographicLocation2LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void ArchaeoLines::customAzimuth1LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void ArchaeoLines::customAzimuth2LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void ArchaeoLines::customAltitude1LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void ArchaeoLines::customAltitude2LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void ArchaeoLines::customDeclination1LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void ArchaeoLines::customDeclination2LabelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void ArchaeoLines::equinoxColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void ArchaeoLines::solsticesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void ArchaeoLines::crossquartersColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void ArchaeoLines::majorStandstillColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void ArchaeoLines::minorStandstillColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 43, nullptr, _t1);
}

// SIGNAL 44
void ArchaeoLines::polarCirclesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void ArchaeoLines::zenithPassageColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1);
}

// SIGNAL 46
void ArchaeoLines::nadirPassageColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void ArchaeoLines::selectedObjectColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 47, nullptr, _t1);
}

// SIGNAL 48
void ArchaeoLines::selectedObjectAzimuthColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void ArchaeoLines::selectedObjectHourAngleColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1);
}

// SIGNAL 50
void ArchaeoLines::currentSunColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 50, nullptr, _t1);
}

// SIGNAL 51
void ArchaeoLines::currentMoonColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 51, nullptr, _t1);
}

// SIGNAL 52
void ArchaeoLines::currentPlanetColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void ArchaeoLines::geographicLocation1ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 53, nullptr, _t1);
}

// SIGNAL 54
void ArchaeoLines::geographicLocation2ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 54, nullptr, _t1);
}

// SIGNAL 55
void ArchaeoLines::customAzimuth1ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 55, nullptr, _t1);
}

// SIGNAL 56
void ArchaeoLines::customAzimuth2ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 56, nullptr, _t1);
}

// SIGNAL 57
void ArchaeoLines::customAltitude1ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 57, nullptr, _t1);
}

// SIGNAL 58
void ArchaeoLines::customAltitude2ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 58, nullptr, _t1);
}

// SIGNAL 59
void ArchaeoLines::customDeclination1ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 59, nullptr, _t1);
}

// SIGNAL 60
void ArchaeoLines::customDeclination2ColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 60, nullptr, _t1);
}

// SIGNAL 61
void ArchaeoLines::lineWidthChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 61, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN31ArchaeoLinesStelPluginInterfaceE_t {};
} // unnamed namespace

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

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

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

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

void *ArchaeoLinesStelPluginInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31ArchaeoLinesStelPluginInterfaceE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "StelPluginInterface"))
        return static_cast< StelPluginInterface*>(this);
    if (!strcmp(_clname, "org.stellarium.StelPluginInterface/2.0"))
        return static_cast< StelPluginInterface*>(this);
    return QObject::qt_metacast(_clname);
}

int ArchaeoLinesStelPluginInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}

#ifdef QT_MOC_EXPORT_PLUGIN_V2
static constexpr unsigned char qt_pluginMetaDataV2_ArchaeoLinesStelPluginInterface[] = {
    0xbf, 
    // "IID"
    0x02,  0x78,  0x26,  'o',  'r',  'g',  '.',  's', 
    't',  'e',  'l',  'l',  'a',  'r',  'i',  'u', 
    'm',  '.',  'S',  't',  'e',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n',  'I',  'n',  't',  'e', 
    'r',  'f',  'a',  'c',  'e',  '/',  '2',  '.', 
    '0', 
    // "className"
    0x03,  0x78,  0x1f,  'A',  'r',  'c',  'h',  'a', 
    'e',  'o',  'L',  'i',  'n',  'e',  's',  'S', 
    't',  'e',  'l',  'P',  'l',  'u',  'g',  'i', 
    'n',  'I',  'n',  't',  'e',  'r',  'f',  'a', 
    'c',  'e', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN_V2(ArchaeoLinesStelPluginInterface, ArchaeoLinesStelPluginInterface, qt_pluginMetaDataV2_ArchaeoLinesStelPluginInterface)
#else
QT_PLUGIN_METADATA_SECTION
Q_CONSTINIT static constexpr unsigned char qt_pluginMetaData_ArchaeoLinesStelPluginInterface[] = {
    'Q', 'T', 'M', 'E', 'T', 'A', 'D', 'A', 'T', 'A', ' ', '!',
    // metadata version, Qt version, architectural requirements
    0, QT_VERSION_MAJOR, QT_VERSION_MINOR, qPluginArchRequirements(),
    0xbf, 
    // "IID"
    0x02,  0x78,  0x26,  'o',  'r',  'g',  '.',  's', 
    't',  'e',  'l',  'l',  'a',  'r',  'i',  'u', 
    'm',  '.',  'S',  't',  'e',  'l',  'P',  'l', 
    'u',  'g',  'i',  'n',  'I',  'n',  't',  'e', 
    'r',  'f',  'a',  'c',  'e',  '/',  '2',  '.', 
    '0', 
    // "className"
    0x03,  0x78,  0x1f,  'A',  'r',  'c',  'h',  'a', 
    'e',  'o',  'L',  'i',  'n',  'e',  's',  'S', 
    't',  'e',  'l',  'P',  'l',  'u',  'g',  'i', 
    'n',  'I',  'n',  't',  'e',  'r',  'f',  'a', 
    'c',  'e', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN(ArchaeoLinesStelPluginInterface, ArchaeoLinesStelPluginInterface)
#endif  // QT_MOC_EXPORT_PLUGIN_V2

QT_WARNING_POP
