/****************************************************************************
** Meta object code from reading C++ file 'SolarSystem.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/src/core/modules/SolarSystem.hpp"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto SolarSystem::qt_create_metaobjectdata<qt_meta_tag_ZN11SolarSystemE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SolarSystem",
        "labelsDisplayedChanged",
        "",
        "b",
        "flagOrbitsChanged",
        "flagHintsChanged",
        "markersDisplayedChanged",
        "flagDrawMoonHaloChanged",
        "flagDrawSunHaloChanged",
        "trailsDisplayedChanged",
        "trailsThicknessChanged",
        "v",
        "orbitsThicknessChanged",
        "maxTrailPointsChanged",
        "max",
        "maxTrailTimeExtentChanged",
        "flagPointerChanged",
        "flagPlanetsDisplayedChanged",
        "flagPlanetsOrbitsChanged",
        "flagPlanetsOrbitsOnlyChanged",
        "flagPermanentOrbitsChanged",
        "flagIsolatedOrbitsChanged",
        "flagOrbitsWithMoonsChanged",
        "flagIsolatedTrailsChanged",
        "numberIsolatedTrailsChanged",
        "n",
        "flagLightTravelTimeChanged",
        "flagUseObjModelsChanged",
        "flagShowObjSelfShadowsChanged",
        "flagMoonScaleChanged",
        "moonScaleChanged",
        "f",
        "flagDynamicMoonScaleChanged",
        "moonScaleMinFovChanged",
        "deg",
        "moonScaleMaxFovChanged",
        "flagMinorBodyScaleChanged",
        "minorBodyScaleChanged",
        "flagPlanetScaleChanged",
        "planetScaleChanged",
        "flagSunScaleChanged",
        "sunScaleChanged",
        "labelsAmountChanged",
        "ephemerisMarkersChanged",
        "ephemerisHorizontalCoordinatesChanged",
        "ephemerisDatesChanged",
        "ephemerisMagnitudesChanged",
        "ephemerisLineChanged",
        "ephemerisAlwaysOnChanged",
        "ephemerisNowChanged",
        "ephemerisLineThicknessChanged",
        "ephemerisSkipDataChanged",
        "ephemerisSkipMarkersChanged",
        "ephemerisDataStepChanged",
        "s",
        "ephemerisDataLimitChanged",
        "ephemerisSmartDatesChanged",
        "ephemerisScaleMarkersChanged",
        "grsLongitudeChanged",
        "l",
        "grsDriftChanged",
        "drift",
        "grsJDChanged",
        "JD",
        "earthShadowEnlargementDanjonChanged",
        "flagPermanentSolarCoronaChanged",
        "labelsColorChanged",
        "Vec3f",
        "color",
        "pointerColorChanged",
        "trailsColorChanged",
        "orbitsColorChanged",
        "nomenclatureColorChanged",
        "majorPlanetsOrbitsColorChanged",
        "minorPlanetsOrbitsColorChanged",
        "dwarfPlanetsOrbitsColorChanged",
        "moonsOrbitsColorChanged",
        "cubewanosOrbitsColorChanged",
        "plutinosOrbitsColorChanged",
        "scatteredDiskObjectsOrbitsColorChanged",
        "oortCloudObjectsOrbitsColorChanged",
        "cometsOrbitsColorChanged",
        "sednoidsOrbitsColorChanged",
        "interstellarOrbitsColorChanged",
        "mercuryOrbitColorChanged",
        "venusOrbitColorChanged",
        "earthOrbitColorChanged",
        "marsOrbitColorChanged",
        "jupiterOrbitColorChanged",
        "saturnOrbitColorChanged",
        "uranusOrbitColorChanged",
        "neptuneOrbitColorChanged",
        "ephemerisGenericMarkerColorChanged",
        "ephemerisSecondaryMarkerColorChanged",
        "ephemerisSelectedMarkerColorChanged",
        "ephemerisMercuryMarkerColorChanged",
        "ephemerisVenusMarkerColorChanged",
        "ephemerisMarsMarkerColorChanged",
        "ephemerisJupiterMarkerColorChanged",
        "ephemerisSaturnMarkerColorChanged",
        "orbitColorStyleChanged",
        "style",
        "apparentMagnitudeAlgorithmOnEarthChanged",
        "algorithm",
        "solarSystemDataReloaded",
        "requestEphemerisVisualization",
        "extraThreadsChanged",
        "markerMagThresholdChanged",
        "m",
        "setFlagPlanets",
        "getFlagPlanets",
        "setFlagTrails",
        "getFlagTrails",
        "setTrailsThickness",
        "getTrailsThickness",
        "setMaxTrailPoints",
        "getMaxTrailPoints",
        "setMaxTrailTimeExtent",
        "getMaxTrailTimeExtent",
        "setFlagHints",
        "getFlagHints",
        "setFlagMarkers",
        "getFlagMarkers",
        "setFlagLabels",
        "getFlagLabels",
        "setLabelsAmount",
        "a",
        "getLabelsAmount",
        "setFlagOrbits",
        "getFlagOrbits",
        "setFlagPointer",
        "getFlagPointer",
        "setFlagLightTravelTime",
        "getFlagLightTravelTime",
        "setFlagUseObjModels",
        "getFlagUseObjModels",
        "setFlagShowObjSelfShadows",
        "getFlagShowObjSelfShadows",
        "setFontSize",
        "newFontSize",
        "setLabelsColor",
        "c",
        "getLabelsColor",
        "setOrbitsColor",
        "getOrbitsColor",
        "setMajorPlanetsOrbitsColor",
        "getMajorPlanetsOrbitsColor",
        "setMoonsOrbitsColor",
        "getMoonsOrbitsColor",
        "setMinorPlanetsOrbitsColor",
        "getMinorPlanetsOrbitsColor",
        "setDwarfPlanetsOrbitsColor",
        "getDwarfPlanetsOrbitsColor",
        "setCubewanosOrbitsColor",
        "getCubewanosOrbitsColor",
        "setPlutinosOrbitsColor",
        "getPlutinosOrbitsColor",
        "setScatteredDiskObjectsOrbitsColor",
        "getScatteredDiskObjectsOrbitsColor",
        "setOortCloudObjectsOrbitsColor",
        "getOortCloudObjectsOrbitsColor",
        "setCometsOrbitsColor",
        "getCometsOrbitsColor",
        "setSednoidsOrbitsColor",
        "getSednoidsOrbitsColor",
        "setInterstellarOrbitsColor",
        "getInterstellarOrbitsColor",
        "setMercuryOrbitColor",
        "getMercuryOrbitColor",
        "setVenusOrbitColor",
        "getVenusOrbitColor",
        "setEarthOrbitColor",
        "getEarthOrbitColor",
        "setMarsOrbitColor",
        "getMarsOrbitColor",
        "setJupiterOrbitColor",
        "getJupiterOrbitColor",
        "setSaturnOrbitColor",
        "getSaturnOrbitColor",
        "setUranusOrbitColor",
        "getUranusOrbitColor",
        "setNeptuneOrbitColor",
        "getNeptuneOrbitColor",
        "setTrailsColor",
        "getTrailsColor",
        "setPointerColor",
        "getPointerColor",
        "setFlagMoonScale",
        "getFlagMoonScale",
        "setMoonScale",
        "getMoonScale",
        "setFlagDynamicMoonScale",
        "getFlagDynamicMoonScale",
        "setMoonScaleMinFov",
        "getMoonScaleMinFov",
        "setMoonScaleMaxFov",
        "getMoonScaleMaxFov",
        "setFlagMinorBodyScale",
        "getFlagMinorBodyScale",
        "setMinorBodyScale",
        "getMinorBodyScale",
        "setFlagPlanetScale",
        "getFlagPlanetScale",
        "setPlanetScale",
        "getPlanetScale",
        "setFlagSunScale",
        "getFlagSunScale",
        "setSunScale",
        "getSunScale",
        "updateI18n",
        "getPlanetVMagnitude",
        "planetName",
        "withExtinction",
        "getPlanetType",
        "getDistanceToPlanet",
        "getElongationForPlanet",
        "getPhaseAngleForPlanet",
        "getPhaseForPlanet",
        "setApparentMagnitudeAlgorithmOnEarth",
        "Planet::ApparentMagnitudeAlgorithm",
        "id",
        "getApparentMagnitudeAlgorithmOnEarth",
        "setFlagIsolatedTrails",
        "getFlagIsolatedTrails",
        "setNumberIsolatedTrails",
        "getNumberIsolatedTrails",
        "setFlagIsolatedOrbits",
        "getFlagIsolatedOrbits",
        "setFlagPlanetsOrbits",
        "getFlagPlanetsOrbits",
        "setFlagPlanetsOrbitsOnly",
        "getFlagPlanetsOrbitsOnly",
        "setFlagOrbitsWithMoons",
        "getFlagOrbitsWithMoons",
        "setFlagPermanentSolarCorona",
        "getFlagPermanentSolarCorona",
        "setGrsLongitude",
        "longitude",
        "getGrsLongitude",
        "setGrsDrift",
        "getGrsDrift",
        "setGrsJD",
        "getGrsJD",
        "setFlagEarthShadowEnlargementDanjon",
        "getFlagEarthShadowEnlargementDanjon",
        "setOrbitColorStyle",
        "getOrbitColorStyle",
        "getObjectsList",
        "objType",
        "setFlagPermanentOrbits",
        "getFlagPermanentOrbits",
        "setOrbitsThickness",
        "getOrbitsThickness",
        "setFlagDrawMoonHalo",
        "getFlagDrawMoonHalo",
        "setFlagDrawSunHalo",
        "getFlagDrawSunHalo",
        "reloadPlanets",
        "recreateTrails",
        "resetTextures",
        "setTextureForPlanet",
        "texName",
        "getExtraThreads",
        "setExtraThreads",
        "getMarkerMagThreshold",
        "setMarkerMagThreshold",
        "enableSurvey",
        "HipsSurveyP",
        "colors",
        "normals",
        "horizons",
        "selectedObjectChange",
        "StelModule::StelModuleSelectAction",
        "action",
        "updateSkyCulture",
        "StelSkyCulture",
        "skyCulture",
        "loadCultureSpecificNames",
        "QJsonObject",
        "data",
        "reloadShaders",
        "setFlagEphemerisMarkers",
        "getFlagEphemerisMarkers",
        "setFlagEphemerisLine",
        "getFlagEphemerisLine",
        "setFlagEphemerisAlwaysOn",
        "getFlagEphemerisAlwaysOn",
        "setFlagEphemerisNow",
        "getFlagEphemerisNow",
        "setEphemerisLineThickness",
        "getEphemerisLineThickness",
        "setFlagEphemerisHorizontalCoordinates",
        "getFlagEphemerisHorizontalCoordinates",
        "setFlagEphemerisDates",
        "getFlagEphemerisDates",
        "setFlagEphemerisMagnitudes",
        "getFlagEphemerisMagnitudes",
        "setFlagEphemerisSkipData",
        "getFlagEphemerisSkipData",
        "setFlagEphemerisSkipMarkers",
        "getFlagEphemerisSkipMarkers",
        "setFlagEphemerisSmartDates",
        "getFlagEphemerisSmartDates",
        "setFlagEphemerisScaleMarkers",
        "getFlagEphemerisScaleMarkers",
        "setEphemerisDataStep",
        "step",
        "getEphemerisDataStep",
        "setEphemerisDataLimit",
        "limit",
        "getEphemerisDataLimit",
        "setEphemerisGenericMarkerColor",
        "getEphemerisGenericMarkerColor",
        "setEphemerisSecondaryMarkerColor",
        "getEphemerisSecondaryMarkerColor",
        "setEphemerisSelectedMarkerColor",
        "getEphemerisSelectedMarkerColor",
        "setEphemerisMercuryMarkerColor",
        "getEphemerisMercuryMarkerColor",
        "setEphemerisVenusMarkerColor",
        "getEphemerisVenusMarkerColor",
        "setEphemerisMarsMarkerColor",
        "getEphemerisMarsMarkerColor",
        "setEphemerisJupiterMarkerColor",
        "getEphemerisJupiterMarkerColor",
        "setEphemerisSaturnMarkerColor",
        "getEphemerisSaturnMarkerColor",
        "fillEphemerisDates",
        "reconfigureOrbits",
        "labelsDisplayed",
        "trailsDisplayed",
        "maxTrailPoints",
        "maxTrailTimeExtent",
        "trailsThickness",
        "flagHints",
        "flagMarkers",
        "flagPointer",
        "planetsDisplayed",
        "flagOrbits",
        "flagPlanetsOrbits",
        "flagPlanetsOrbitsOnly",
        "flagPermanentOrbits",
        "flagIsolatedOrbits",
        "flagOrbitsWithMoons",
        "flagIsolatedTrails",
        "numberIsolatedTrails",
        "flagLightTravelTime",
        "flagUseObjModels",
        "flagShowObjSelfShadows",
        "flagMoonScale",
        "moonScale",
        "flagDynamicMoonScale",
        "moonScaleMinFov",
        "moonScaleMaxFov",
        "flagMinorBodyScale",
        "minorBodyScale",
        "flagPlanetScale",
        "planetScale",
        "flagSunScale",
        "sunScale",
        "labelsAmount",
        "flagPermanentSolarCorona",
        "ephemerisMarkersDisplayed",
        "ephemerisHorizontalCoordinates",
        "ephemerisDatesDisplayed",
        "ephemerisMagnitudesDisplayed",
        "ephemerisLineDisplayed",
        "ephemerisLineThickness",
        "ephemerisSkippedData",
        "ephemerisSkippedMarkers",
        "ephemerisDataStep",
        "ephemerisDataLimit",
        "ephemerisSmartDates",
        "ephemerisScaleMarkersDisplayed",
        "ephemerisAlwaysOn",
        "ephemerisNow",
        "grsLongitude",
        "grsDrift",
        "grsJD",
        "earthShadowEnlargementDanjon",
        "labelsColor",
        "pointerColor",
        "trailsColor",
        "orbitsColor",
        "majorPlanetsOrbitsColor",
        "minorPlanetsOrbitsColor",
        "dwarfPlanetsOrbitsColor",
        "moonsOrbitsColor",
        "cubewanosOrbitsColor",
        "plutinosOrbitsColor",
        "scatteredDiskObjectsOrbitsColor",
        "oortCloudObjectsOrbitsColor",
        "cometsOrbitsColor",
        "sednoidsOrbitsColor",
        "interstellarOrbitsColor",
        "mercuryOrbitColor",
        "venusOrbitColor",
        "earthOrbitColor",
        "marsOrbitColor",
        "jupiterOrbitColor",
        "saturnOrbitColor",
        "uranusOrbitColor",
        "neptuneOrbitColor",
        "ephemerisGenericMarkerColor",
        "ephemerisSecondaryMarkerColor",
        "ephemerisSelectedMarkerColor",
        "ephemerisMercuryMarkerColor",
        "ephemerisVenusMarkerColor",
        "ephemerisMarsMarkerColor",
        "ephemerisJupiterMarkerColor",
        "ephemerisSaturnMarkerColor",
        "orbitColorStyle",
        "apparentMagnitudeAlgorithmOnEarth",
        "orbitsThickness",
        "flagDrawMoonHalo",
        "flagDrawSunHalo",
        "extraThreads",
        "markerMagThreshold"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'labelsDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagOrbitsChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagHintsChanged'
        QtMocHelpers::SignalData<void(bool)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'markersDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagDrawMoonHaloChanged'
        QtMocHelpers::SignalData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagDrawSunHaloChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'trailsDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'trailsThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Signal 'orbitsThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Signal 'maxTrailPointsChanged'
        QtMocHelpers::SignalData<void(int)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'maxTrailTimeExtentChanged'
        QtMocHelpers::SignalData<void(int)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'flagPointerChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagPlanetsDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagPlanetsOrbitsChanged'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagPlanetsOrbitsOnlyChanged'
        QtMocHelpers::SignalData<void(bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagPermanentOrbitsChanged'
        QtMocHelpers::SignalData<void(bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagIsolatedOrbitsChanged'
        QtMocHelpers::SignalData<void(bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagOrbitsWithMoonsChanged'
        QtMocHelpers::SignalData<void(bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagIsolatedTrailsChanged'
        QtMocHelpers::SignalData<void(bool)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'numberIsolatedTrailsChanged'
        QtMocHelpers::SignalData<void(int)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 25 },
        }}),
        // Signal 'flagLightTravelTimeChanged'
        QtMocHelpers::SignalData<void(bool)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagUseObjModelsChanged'
        QtMocHelpers::SignalData<void(bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagShowObjSelfShadowsChanged'
        QtMocHelpers::SignalData<void(bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagMoonScaleChanged'
        QtMocHelpers::SignalData<void(bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'moonScaleChanged'
        QtMocHelpers::SignalData<void(double)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Signal 'flagDynamicMoonScaleChanged'
        QtMocHelpers::SignalData<void(bool)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'moonScaleMinFovChanged'
        QtMocHelpers::SignalData<void(double)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 34 },
        }}),
        // Signal 'moonScaleMaxFovChanged'
        QtMocHelpers::SignalData<void(double)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 34 },
        }}),
        // Signal 'flagMinorBodyScaleChanged'
        QtMocHelpers::SignalData<void(bool)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minorBodyScaleChanged'
        QtMocHelpers::SignalData<void(double)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Signal 'flagPlanetScaleChanged'
        QtMocHelpers::SignalData<void(bool)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'planetScaleChanged'
        QtMocHelpers::SignalData<void(double)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Signal 'flagSunScaleChanged'
        QtMocHelpers::SignalData<void(bool)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'sunScaleChanged'
        QtMocHelpers::SignalData<void(double)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Signal 'labelsAmountChanged'
        QtMocHelpers::SignalData<void(double)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Signal 'ephemerisMarkersChanged'
        QtMocHelpers::SignalData<void(bool)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisHorizontalCoordinatesChanged'
        QtMocHelpers::SignalData<void(bool)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisDatesChanged'
        QtMocHelpers::SignalData<void(bool)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisMagnitudesChanged'
        QtMocHelpers::SignalData<void(bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisLineChanged'
        QtMocHelpers::SignalData<void(bool)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisAlwaysOnChanged'
        QtMocHelpers::SignalData<void(bool)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisNowChanged'
        QtMocHelpers::SignalData<void(bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisLineThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Signal 'ephemerisSkipDataChanged'
        QtMocHelpers::SignalData<void(bool)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisSkipMarkersChanged'
        QtMocHelpers::SignalData<void(bool)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisDataStepChanged'
        QtMocHelpers::SignalData<void(int)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Signal 'ephemerisDataLimitChanged'
        QtMocHelpers::SignalData<void(int)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Signal 'ephemerisSmartDatesChanged'
        QtMocHelpers::SignalData<void(bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ephemerisScaleMarkersChanged'
        QtMocHelpers::SignalData<void(bool)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'grsLongitudeChanged'
        QtMocHelpers::SignalData<void(int)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 59 },
        }}),
        // Signal 'grsDriftChanged'
        QtMocHelpers::SignalData<void(double)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 61 },
        }}),
        // Signal 'grsJDChanged'
        QtMocHelpers::SignalData<void(double)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 63 },
        }}),
        // Signal 'earthShadowEnlargementDanjonChanged'
        QtMocHelpers::SignalData<void(bool)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagPermanentSolarCoronaChanged'
        QtMocHelpers::SignalData<void(bool)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'labelsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'pointerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'trailsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'orbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'nomenclatureColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'majorPlanetsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'minorPlanetsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'dwarfPlanetsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'moonsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'cubewanosOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'plutinosOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'scatteredDiskObjectsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'oortCloudObjectsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'cometsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'sednoidsOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'interstellarOrbitsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'mercuryOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'venusOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'earthOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'marsOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'jupiterOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'saturnOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'uranusOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'neptuneOrbitColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisGenericMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisSecondaryMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisSelectedMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisMercuryMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisVenusMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisMarsMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(97, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisJupiterMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'ephemerisSaturnMarkerColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Signal 'orbitColorStyleChanged'
        QtMocHelpers::SignalData<void(const QString &)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 101 },
        }}),
        // Signal 'apparentMagnitudeAlgorithmOnEarthChanged'
        QtMocHelpers::SignalData<void(const QString &)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 103 },
        }}),
        // Signal 'solarSystemDataReloaded'
        QtMocHelpers::SignalData<void()>(104, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'requestEphemerisVisualization'
        QtMocHelpers::SignalData<void()>(105, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'extraThreadsChanged'
        QtMocHelpers::SignalData<void(const int)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
        // Signal 'markerMagThresholdChanged'
        QtMocHelpers::SignalData<void(double)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 108 },
        }}),
        // Slot 'setFlagPlanets'
        QtMocHelpers::SlotData<void(bool)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPlanets'
        QtMocHelpers::SlotData<bool() const>(110, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagTrails'
        QtMocHelpers::SlotData<void(bool)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagTrails'
        QtMocHelpers::SlotData<bool() const>(112, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setTrailsThickness'
        QtMocHelpers::SlotData<void(int)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'getTrailsThickness'
        QtMocHelpers::SlotData<int() const>(114, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setMaxTrailPoints'
        QtMocHelpers::SlotData<void(int)>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getMaxTrailPoints'
        QtMocHelpers::SlotData<int() const>(116, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setMaxTrailTimeExtent'
        QtMocHelpers::SlotData<void(int)>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getMaxTrailTimeExtent'
        QtMocHelpers::SlotData<int() const>(118, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setFlagHints'
        QtMocHelpers::SlotData<void(bool)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagHints'
        QtMocHelpers::SlotData<bool() const>(120, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagMarkers'
        QtMocHelpers::SlotData<void(bool)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagMarkers'
        QtMocHelpers::SlotData<bool() const>(122, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLabels'
        QtMocHelpers::SlotData<void(bool)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagLabels'
        QtMocHelpers::SlotData<bool() const>(124, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLabelsAmount'
        QtMocHelpers::SlotData<void(double)>(125, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 126 },
        }}),
        // Slot 'getLabelsAmount'
        QtMocHelpers::SlotData<double() const>(127, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagOrbits'
        QtMocHelpers::SlotData<void(bool)>(128, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagOrbits'
        QtMocHelpers::SlotData<bool() const>(129, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPointer'
        QtMocHelpers::SlotData<void(bool)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPointer'
        QtMocHelpers::SlotData<bool() const>(131, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLightTravelTime'
        QtMocHelpers::SlotData<void(bool)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagLightTravelTime'
        QtMocHelpers::SlotData<bool() const>(133, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagUseObjModels'
        QtMocHelpers::SlotData<void(bool)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagUseObjModels'
        QtMocHelpers::SlotData<bool() const>(135, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagShowObjSelfShadows'
        QtMocHelpers::SlotData<void(bool)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagShowObjSelfShadows'
        QtMocHelpers::SlotData<bool() const>(137, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFontSize'
        QtMocHelpers::SlotData<void(int)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 139 },
        }}),
        // Slot 'setLabelsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getLabelsColor'
        QtMocHelpers::SlotData<Vec3f() const>(142, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(143, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(144, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setMajorPlanetsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getMajorPlanetsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(146, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setMoonsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getMoonsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(148, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setMinorPlanetsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(149, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getMinorPlanetsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(150, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setDwarfPlanetsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(151, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getDwarfPlanetsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(152, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setCubewanosOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(153, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getCubewanosOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(154, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setPlutinosOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getPlutinosOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(156, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setScatteredDiskObjectsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(157, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getScatteredDiskObjectsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(158, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setOortCloudObjectsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(159, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getOortCloudObjectsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(160, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setCometsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(161, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getCometsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(162, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setSednoidsOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(163, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getSednoidsOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(164, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setInterstellarOrbitsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getInterstellarOrbitsColor'
        QtMocHelpers::SlotData<Vec3f() const>(166, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setMercuryOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(167, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getMercuryOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(168, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setVenusOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getVenusOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(170, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setEarthOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(171, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEarthOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(172, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setMarsOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getMarsOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(174, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setJupiterOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(175, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getJupiterOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(176, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setSaturnOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(177, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getSaturnOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(178, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setUranusOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(179, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getUranusOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(180, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setNeptuneOrbitColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(181, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getNeptuneOrbitColor'
        QtMocHelpers::SlotData<Vec3f() const>(182, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setTrailsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(183, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getTrailsColor'
        QtMocHelpers::SlotData<Vec3f() const>(184, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setPointerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(185, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getPointerColor'
        QtMocHelpers::SlotData<Vec3f() const>(186, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'setFlagMoonScale'
        QtMocHelpers::SlotData<void(bool)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagMoonScale'
        QtMocHelpers::SlotData<bool() const>(188, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMoonScale'
        QtMocHelpers::SlotData<void(double)>(189, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Slot 'getMoonScale'
        QtMocHelpers::SlotData<double() const>(190, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagDynamicMoonScale'
        QtMocHelpers::SlotData<void(bool)>(191, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagDynamicMoonScale'
        QtMocHelpers::SlotData<bool() const>(192, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMoonScaleMinFov'
        QtMocHelpers::SlotData<void(double)>(193, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 34 },
        }}),
        // Slot 'getMoonScaleMinFov'
        QtMocHelpers::SlotData<double() const>(194, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMoonScaleMaxFov'
        QtMocHelpers::SlotData<void(double)>(195, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 34 },
        }}),
        // Slot 'getMoonScaleMaxFov'
        QtMocHelpers::SlotData<double() const>(196, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagMinorBodyScale'
        QtMocHelpers::SlotData<void(bool)>(197, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagMinorBodyScale'
        QtMocHelpers::SlotData<bool() const>(198, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMinorBodyScale'
        QtMocHelpers::SlotData<void(double)>(199, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Slot 'getMinorBodyScale'
        QtMocHelpers::SlotData<double() const>(200, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagPlanetScale'
        QtMocHelpers::SlotData<void(bool)>(201, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPlanetScale'
        QtMocHelpers::SlotData<bool() const>(202, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setPlanetScale'
        QtMocHelpers::SlotData<void(double)>(203, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Slot 'getPlanetScale'
        QtMocHelpers::SlotData<double() const>(204, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagSunScale'
        QtMocHelpers::SlotData<void(bool)>(205, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagSunScale'
        QtMocHelpers::SlotData<bool() const>(206, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setSunScale'
        QtMocHelpers::SlotData<void(double)>(207, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 31 },
        }}),
        // Slot 'getSunScale'
        QtMocHelpers::SlotData<double() const>(208, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'updateI18n'
        QtMocHelpers::SlotData<void()>(209, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getPlanetVMagnitude'
        QtMocHelpers::SlotData<float(const QString &, bool) const>(210, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::QString, 211 }, { QMetaType::Bool, 212 },
        }}),
        // Slot 'getPlanetVMagnitude'
        QtMocHelpers::SlotData<float(const QString &) const>(210, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Float, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'getPlanetType'
        QtMocHelpers::SlotData<QString(const QString &) const>(213, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'getDistanceToPlanet'
        QtMocHelpers::SlotData<double(const QString &) const>(214, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'getElongationForPlanet'
        QtMocHelpers::SlotData<double(const QString &) const>(215, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'getPhaseAngleForPlanet'
        QtMocHelpers::SlotData<double(const QString &) const>(216, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'getPhaseForPlanet'
        QtMocHelpers::SlotData<float(const QString &) const>(217, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'setApparentMagnitudeAlgorithmOnEarth'
        QtMocHelpers::SlotData<void(const QString &)>(218, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 103 },
        }}),
        // Slot 'setApparentMagnitudeAlgorithmOnEarth'
        QtMocHelpers::SlotData<void(const Planet::ApparentMagnitudeAlgorithm)>(218, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 219, 220 },
        }}),
        // Slot 'getApparentMagnitudeAlgorithmOnEarth'
        QtMocHelpers::SlotData<QString() const>(221, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setFlagIsolatedTrails'
        QtMocHelpers::SlotData<void(bool)>(222, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagIsolatedTrails'
        QtMocHelpers::SlotData<bool() const>(223, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setNumberIsolatedTrails'
        QtMocHelpers::SlotData<void(int)>(224, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 25 },
        }}),
        // Slot 'getNumberIsolatedTrails'
        QtMocHelpers::SlotData<int() const>(225, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setFlagIsolatedOrbits'
        QtMocHelpers::SlotData<void(bool)>(226, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagIsolatedOrbits'
        QtMocHelpers::SlotData<bool() const>(227, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPlanetsOrbits'
        QtMocHelpers::SlotData<void(bool)>(228, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPlanetsOrbits'
        QtMocHelpers::SlotData<bool() const>(229, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPlanetsOrbitsOnly'
        QtMocHelpers::SlotData<void(bool)>(230, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPlanetsOrbitsOnly'
        QtMocHelpers::SlotData<bool() const>(231, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagOrbitsWithMoons'
        QtMocHelpers::SlotData<void(bool)>(232, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagOrbitsWithMoons'
        QtMocHelpers::SlotData<bool() const>(233, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPermanentSolarCorona'
        QtMocHelpers::SlotData<void(bool)>(234, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPermanentSolarCorona'
        QtMocHelpers::SlotData<bool() const>(235, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setGrsLongitude'
        QtMocHelpers::SlotData<void(int)>(236, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 237 },
        }}),
        // Slot 'getGrsLongitude'
        QtMocHelpers::SlotData<int() const>(238, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setGrsDrift'
        QtMocHelpers::SlotData<void(double)>(239, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 61 },
        }}),
        // Slot 'getGrsDrift'
        QtMocHelpers::SlotData<double() const>(240, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setGrsJD'
        QtMocHelpers::SlotData<void(double)>(241, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 63 },
        }}),
        // Slot 'getGrsJD'
        QtMocHelpers::SlotData<double()>(242, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setFlagEarthShadowEnlargementDanjon'
        QtMocHelpers::SlotData<void(bool)>(243, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEarthShadowEnlargementDanjon'
        QtMocHelpers::SlotData<bool() const>(244, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setOrbitColorStyle'
        QtMocHelpers::SlotData<void(const QString &)>(245, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 101 },
        }}),
        // Slot 'getOrbitColorStyle'
        QtMocHelpers::SlotData<QString() const>(246, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getObjectsList'
        QtMocHelpers::SlotData<QStringList(QString) const>(247, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::QString, 248 },
        }}),
        // Slot 'getObjectsList'
        QtMocHelpers::SlotData<QStringList() const>(247, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QStringList),
        // Slot 'setFlagPermanentOrbits'
        QtMocHelpers::SlotData<void(bool)>(249, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagPermanentOrbits'
        QtMocHelpers::SlotData<bool() const>(250, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setOrbitsThickness'
        QtMocHelpers::SlotData<void(int)>(251, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'getOrbitsThickness'
        QtMocHelpers::SlotData<int() const>(252, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setFlagDrawMoonHalo'
        QtMocHelpers::SlotData<void(bool)>(253, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagDrawMoonHalo'
        QtMocHelpers::SlotData<bool() const>(254, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagDrawSunHalo'
        QtMocHelpers::SlotData<void(bool)>(255, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagDrawSunHalo'
        QtMocHelpers::SlotData<bool() const>(256, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'reloadPlanets'
        QtMocHelpers::SlotData<void()>(257, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'recreateTrails'
        QtMocHelpers::SlotData<void()>(258, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetTextures'
        QtMocHelpers::SlotData<void(const QString &)>(259, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 211 },
        }}),
        // Slot 'setTextureForPlanet'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(260, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 211 }, { QMetaType::QString, 261 },
        }}),
        // Slot 'getExtraThreads'
        QtMocHelpers::SlotData<int() const>(262, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setExtraThreads'
        QtMocHelpers::SlotData<void(int)>(263, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 25 },
        }}),
        // Slot 'getMarkerMagThreshold'
        QtMocHelpers::SlotData<double() const>(264, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMarkerMagThreshold'
        QtMocHelpers::SlotData<void(double)>(265, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 108 },
        }}),
        // Slot 'enableSurvey'
        QtMocHelpers::SlotData<void(const HipsSurveyP &, const HipsSurveyP &, const HipsSurveyP &)>(266, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 267, 268 }, { 0x80000000 | 267, 269 }, { 0x80000000 | 267, 270 },
        }}),
        // Slot 'selectedObjectChange'
        QtMocHelpers::SlotData<void(StelModule::StelModuleSelectAction)>(271, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 272, 273 },
        }}),
        // Slot 'updateSkyCulture'
        QtMocHelpers::SlotData<void(const StelSkyCulture &)>(274, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 275, 276 },
        }}),
        // Slot 'loadCultureSpecificNames'
        QtMocHelpers::SlotData<void(const QJsonObject &)>(277, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 278, 279 },
        }}),
        // Slot 'reloadShaders'
        QtMocHelpers::SlotData<void()>(280, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setFlagEphemerisMarkers'
        QtMocHelpers::SlotData<void(bool)>(281, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisMarkers'
        QtMocHelpers::SlotData<bool() const>(282, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisLine'
        QtMocHelpers::SlotData<void(bool)>(283, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisLine'
        QtMocHelpers::SlotData<bool() const>(284, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisAlwaysOn'
        QtMocHelpers::SlotData<void(bool)>(285, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisAlwaysOn'
        QtMocHelpers::SlotData<bool() const>(286, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisNow'
        QtMocHelpers::SlotData<void(bool)>(287, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisNow'
        QtMocHelpers::SlotData<bool() const>(288, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setEphemerisLineThickness'
        QtMocHelpers::SlotData<void(int)>(289, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 11 },
        }}),
        // Slot 'getEphemerisLineThickness'
        QtMocHelpers::SlotData<int() const>(290, 2, QMC::AccessPrivate, QMetaType::Int),
        // Slot 'setFlagEphemerisHorizontalCoordinates'
        QtMocHelpers::SlotData<void(bool)>(291, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisHorizontalCoordinates'
        QtMocHelpers::SlotData<bool() const>(292, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisDates'
        QtMocHelpers::SlotData<void(bool)>(293, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisDates'
        QtMocHelpers::SlotData<bool() const>(294, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisMagnitudes'
        QtMocHelpers::SlotData<void(bool)>(295, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisMagnitudes'
        QtMocHelpers::SlotData<bool() const>(296, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisSkipData'
        QtMocHelpers::SlotData<void(bool)>(297, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisSkipData'
        QtMocHelpers::SlotData<bool() const>(298, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisSkipMarkers'
        QtMocHelpers::SlotData<void(bool)>(299, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisSkipMarkers'
        QtMocHelpers::SlotData<bool() const>(300, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisSmartDates'
        QtMocHelpers::SlotData<void(bool)>(301, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisSmartDates'
        QtMocHelpers::SlotData<bool() const>(302, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setFlagEphemerisScaleMarkers'
        QtMocHelpers::SlotData<void(bool)>(303, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagEphemerisScaleMarkers'
        QtMocHelpers::SlotData<bool() const>(304, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'setEphemerisDataStep'
        QtMocHelpers::SlotData<void(int)>(305, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 306 },
        }}),
        // Slot 'getEphemerisDataStep'
        QtMocHelpers::SlotData<int() const>(307, 2, QMC::AccessPrivate, QMetaType::Int),
        // Slot 'setEphemerisDataLimit'
        QtMocHelpers::SlotData<void(int)>(308, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 309 },
        }}),
        // Slot 'getEphemerisDataLimit'
        QtMocHelpers::SlotData<int() const>(310, 2, QMC::AccessPrivate, QMetaType::Int),
        // Slot 'setEphemerisGenericMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(311, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisGenericMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(312, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisSecondaryMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(313, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisSecondaryMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(314, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisSelectedMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(315, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisSelectedMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(316, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisMercuryMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(317, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisMercuryMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(318, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisVenusMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(319, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisVenusMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(320, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisMarsMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(321, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisMarsMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(322, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisJupiterMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(323, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisJupiterMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(324, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'setEphemerisSaturnMarkerColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(325, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 67, 141 },
        }}),
        // Slot 'getEphemerisSaturnMarkerColor'
        QtMocHelpers::SlotData<Vec3f() const>(326, 2, QMC::AccessPrivate, 0x80000000 | 67),
        // Slot 'fillEphemerisDates'
        QtMocHelpers::SlotData<void()>(327, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'reconfigureOrbits'
        QtMocHelpers::SlotData<void()>(328, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'labelsDisplayed'
        QtMocHelpers::PropertyData<bool>(329, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'trailsDisplayed'
        QtMocHelpers::PropertyData<bool>(330, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 6),
        // property 'maxTrailPoints'
        QtMocHelpers::PropertyData<int>(331, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'maxTrailTimeExtent'
        QtMocHelpers::PropertyData<int>(332, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'trailsThickness'
        QtMocHelpers::PropertyData<int>(333, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'flagHints'
        QtMocHelpers::PropertyData<bool>(334, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'flagMarkers'
        QtMocHelpers::PropertyData<bool>(335, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'flagPointer'
        QtMocHelpers::PropertyData<bool>(336, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'planetsDisplayed'
        QtMocHelpers::PropertyData<bool>(337, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'flagOrbits'
        QtMocHelpers::PropertyData<bool>(338, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'flagPlanetsOrbits'
        QtMocHelpers::PropertyData<bool>(339, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'flagPlanetsOrbitsOnly'
        QtMocHelpers::PropertyData<bool>(340, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'flagPermanentOrbits'
        QtMocHelpers::PropertyData<bool>(341, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'flagIsolatedOrbits'
        QtMocHelpers::PropertyData<bool>(342, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'flagOrbitsWithMoons'
        QtMocHelpers::PropertyData<bool>(343, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'flagIsolatedTrails'
        QtMocHelpers::PropertyData<bool>(344, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'numberIsolatedTrails'
        QtMocHelpers::PropertyData<int>(345, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'flagLightTravelTime'
        QtMocHelpers::PropertyData<bool>(346, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'flagUseObjModels'
        QtMocHelpers::PropertyData<bool>(347, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'flagShowObjSelfShadows'
        QtMocHelpers::PropertyData<bool>(348, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'flagMoonScale'
        QtMocHelpers::PropertyData<bool>(349, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'moonScale'
        QtMocHelpers::PropertyData<double>(350, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'flagDynamicMoonScale'
        QtMocHelpers::PropertyData<bool>(351, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'moonScaleMinFov'
        QtMocHelpers::PropertyData<double>(352, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'moonScaleMaxFov'
        QtMocHelpers::PropertyData<double>(353, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'flagMinorBodyScale'
        QtMocHelpers::PropertyData<bool>(354, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'minorBodyScale'
        QtMocHelpers::PropertyData<double>(355, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'flagPlanetScale'
        QtMocHelpers::PropertyData<bool>(356, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 30),
        // property 'planetScale'
        QtMocHelpers::PropertyData<double>(357, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 31),
        // property 'flagSunScale'
        QtMocHelpers::PropertyData<bool>(358, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 32),
        // property 'sunScale'
        QtMocHelpers::PropertyData<double>(359, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 33),
        // property 'labelsAmount'
        QtMocHelpers::PropertyData<double>(360, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 34),
        // property 'flagPermanentSolarCorona'
        QtMocHelpers::PropertyData<bool>(361, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 53),
        // property 'ephemerisMarkersDisplayed'
        QtMocHelpers::PropertyData<bool>(362, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 35),
        // property 'ephemerisHorizontalCoordinates'
        QtMocHelpers::PropertyData<bool>(363, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 36),
        // property 'ephemerisDatesDisplayed'
        QtMocHelpers::PropertyData<bool>(364, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 37),
        // property 'ephemerisMagnitudesDisplayed'
        QtMocHelpers::PropertyData<bool>(365, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 38),
        // property 'ephemerisLineDisplayed'
        QtMocHelpers::PropertyData<bool>(366, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 39),
        // property 'ephemerisLineThickness'
        QtMocHelpers::PropertyData<int>(367, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 42),
        // property 'ephemerisSkippedData'
        QtMocHelpers::PropertyData<bool>(368, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 43),
        // property 'ephemerisSkippedMarkers'
        QtMocHelpers::PropertyData<bool>(369, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 44),
        // property 'ephemerisDataStep'
        QtMocHelpers::PropertyData<int>(370, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 45),
        // property 'ephemerisDataLimit'
        QtMocHelpers::PropertyData<int>(371, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 46),
        // property 'ephemerisSmartDates'
        QtMocHelpers::PropertyData<bool>(372, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 47),
        // property 'ephemerisScaleMarkersDisplayed'
        QtMocHelpers::PropertyData<bool>(373, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 48),
        // property 'ephemerisAlwaysOn'
        QtMocHelpers::PropertyData<bool>(374, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 40),
        // property 'ephemerisNow'
        QtMocHelpers::PropertyData<bool>(375, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 41),
        // property 'grsLongitude'
        QtMocHelpers::PropertyData<int>(376, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 49),
        // property 'grsDrift'
        QtMocHelpers::PropertyData<double>(377, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 50),
        // property 'grsJD'
        QtMocHelpers::PropertyData<double>(378, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 51),
        // property 'earthShadowEnlargementDanjon'
        QtMocHelpers::PropertyData<bool>(379, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 52),
        // property 'labelsColor'
        QtMocHelpers::PropertyData<Vec3f>(380, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 54),
        // property 'pointerColor'
        QtMocHelpers::PropertyData<Vec3f>(381, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 55),
        // property 'trailsColor'
        QtMocHelpers::PropertyData<Vec3f>(382, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 56),
        // property 'orbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(383, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 57),
        // property 'majorPlanetsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(384, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 59),
        // property 'minorPlanetsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(385, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 60),
        // property 'dwarfPlanetsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(386, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 61),
        // property 'moonsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(387, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 62),
        // property 'cubewanosOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(388, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 63),
        // property 'plutinosOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(389, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 64),
        // property 'scatteredDiskObjectsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(390, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 65),
        // property 'oortCloudObjectsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(391, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 66),
        // property 'cometsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(392, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 67),
        // property 'sednoidsOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(393, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 68),
        // property 'interstellarOrbitsColor'
        QtMocHelpers::PropertyData<Vec3f>(394, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 69),
        // property 'mercuryOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(395, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 70),
        // property 'venusOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(396, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 71),
        // property 'earthOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(397, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 72),
        // property 'marsOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(398, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 73),
        // property 'jupiterOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(399, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 74),
        // property 'saturnOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(400, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 75),
        // property 'uranusOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(401, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 76),
        // property 'neptuneOrbitColor'
        QtMocHelpers::PropertyData<Vec3f>(402, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 77),
        // property 'ephemerisGenericMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(403, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 78),
        // property 'ephemerisSecondaryMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(404, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 79),
        // property 'ephemerisSelectedMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(405, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 80),
        // property 'ephemerisMercuryMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(406, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 81),
        // property 'ephemerisVenusMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(407, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 82),
        // property 'ephemerisMarsMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(408, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 83),
        // property 'ephemerisJupiterMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(409, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 84),
        // property 'ephemerisSaturnMarkerColor'
        QtMocHelpers::PropertyData<Vec3f>(410, 0x80000000 | 67, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 85),
        // property 'orbitColorStyle'
        QtMocHelpers::PropertyData<QString>(411, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 86),
        // property 'apparentMagnitudeAlgorithmOnEarth'
        QtMocHelpers::PropertyData<QString>(412, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 87),
        // property 'orbitsThickness'
        QtMocHelpers::PropertyData<int>(413, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'flagDrawMoonHalo'
        QtMocHelpers::PropertyData<bool>(414, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'flagDrawSunHalo'
        QtMocHelpers::PropertyData<bool>(415, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'extraThreads'
        QtMocHelpers::PropertyData<int>(416, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 90),
        // property 'markerMagThreshold'
        QtMocHelpers::PropertyData<double>(417, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 91),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<SolarSystem, qt_meta_tag_ZN11SolarSystemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject SolarSystem::staticMetaObject = { {
    QMetaObject::SuperData::link<StelObjectModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11SolarSystemE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11SolarSystemE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11SolarSystemE_t>.metaTypes,
    nullptr
} };

void SolarSystem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SolarSystem *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->labelsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->flagOrbitsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->flagHintsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->markersDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->flagDrawMoonHaloChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->flagDrawSunHaloChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->trailsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->trailsThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->orbitsThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->maxTrailPointsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->maxTrailTimeExtentChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->flagPointerChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->flagPlanetsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->flagPlanetsOrbitsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->flagPlanetsOrbitsOnlyChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->flagPermanentOrbitsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->flagIsolatedOrbitsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->flagOrbitsWithMoonsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->flagIsolatedTrailsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->numberIsolatedTrailsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 20: _t->flagLightTravelTimeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->flagUseObjModelsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->flagShowObjSelfShadowsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 23: _t->flagMoonScaleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->moonScaleChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 25: _t->flagDynamicMoonScaleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 26: _t->moonScaleMinFovChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 27: _t->moonScaleMaxFovChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 28: _t->flagMinorBodyScaleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->minorBodyScaleChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 30: _t->flagPlanetScaleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: _t->planetScaleChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 32: _t->flagSunScaleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->sunScaleChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 34: _t->labelsAmountChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 35: _t->ephemerisMarkersChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->ephemerisHorizontalCoordinatesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->ephemerisDatesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->ephemerisMagnitudesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: _t->ephemerisLineChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: _t->ephemerisAlwaysOnChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 41: _t->ephemerisNowChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 42: _t->ephemerisLineThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 43: _t->ephemerisSkipDataChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: _t->ephemerisSkipMarkersChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: _t->ephemerisDataStepChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 46: _t->ephemerisDataLimitChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 47: _t->ephemerisSmartDatesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: _t->ephemerisScaleMarkersChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 49: _t->grsLongitudeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 50: _t->grsDriftChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 51: _t->grsJDChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 52: _t->earthShadowEnlargementDanjonChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 53: _t->flagPermanentSolarCoronaChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: _t->labelsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 55: _t->pointerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 56: _t->trailsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 57: _t->orbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 58: _t->nomenclatureColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 59: _t->majorPlanetsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 60: _t->minorPlanetsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 61: _t->dwarfPlanetsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 62: _t->moonsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 63: _t->cubewanosOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 64: _t->plutinosOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 65: _t->scatteredDiskObjectsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 66: _t->oortCloudObjectsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 67: _t->cometsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 68: _t->sednoidsOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 69: _t->interstellarOrbitsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 70: _t->mercuryOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 71: _t->venusOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 72: _t->earthOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 73: _t->marsOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 74: _t->jupiterOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 75: _t->saturnOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 76: _t->uranusOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 77: _t->neptuneOrbitColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 78: _t->ephemerisGenericMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 79: _t->ephemerisSecondaryMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 80: _t->ephemerisSelectedMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 81: _t->ephemerisMercuryMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 82: _t->ephemerisVenusMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 83: _t->ephemerisMarsMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 84: _t->ephemerisJupiterMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 85: _t->ephemerisSaturnMarkerColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 86: _t->orbitColorStyleChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 87: _t->apparentMagnitudeAlgorithmOnEarthChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 88: _t->solarSystemDataReloaded(); break;
        case 89: _t->requestEphemerisVisualization(); break;
        case 90: _t->extraThreadsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 91: _t->markerMagThresholdChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 92: _t->setFlagPlanets((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 93: { bool _r = _t->getFlagPlanets();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 94: _t->setFlagTrails((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 95: { bool _r = _t->getFlagTrails();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 96: _t->setTrailsThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 97: { int _r = _t->getTrailsThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 98: _t->setMaxTrailPoints((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 99: { int _r = _t->getMaxTrailPoints();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 100: _t->setMaxTrailTimeExtent((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 101: { int _r = _t->getMaxTrailTimeExtent();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 102: _t->setFlagHints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 103: { bool _r = _t->getFlagHints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 104: _t->setFlagMarkers((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 105: { bool _r = _t->getFlagMarkers();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 106: _t->setFlagLabels((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 107: { bool _r = _t->getFlagLabels();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 108: _t->setLabelsAmount((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 109: { double _r = _t->getLabelsAmount();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 110: _t->setFlagOrbits((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 111: { bool _r = _t->getFlagOrbits();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 112: _t->setFlagPointer((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 113: { bool _r = _t->getFlagPointer();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 114: _t->setFlagLightTravelTime((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 115: { bool _r = _t->getFlagLightTravelTime();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 116: _t->setFlagUseObjModels((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 117: { bool _r = _t->getFlagUseObjModels();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 118: _t->setFlagShowObjSelfShadows((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 119: { bool _r = _t->getFlagShowObjSelfShadows();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 120: _t->setFontSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 121: _t->setLabelsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 122: { Vec3f _r = _t->getLabelsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 123: _t->setOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 124: { Vec3f _r = _t->getOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 125: _t->setMajorPlanetsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 126: { Vec3f _r = _t->getMajorPlanetsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 127: _t->setMoonsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 128: { Vec3f _r = _t->getMoonsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 129: _t->setMinorPlanetsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 130: { Vec3f _r = _t->getMinorPlanetsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 131: _t->setDwarfPlanetsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 132: { Vec3f _r = _t->getDwarfPlanetsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 133: _t->setCubewanosOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 134: { Vec3f _r = _t->getCubewanosOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 135: _t->setPlutinosOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 136: { Vec3f _r = _t->getPlutinosOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 137: _t->setScatteredDiskObjectsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 138: { Vec3f _r = _t->getScatteredDiskObjectsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 139: _t->setOortCloudObjectsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 140: { Vec3f _r = _t->getOortCloudObjectsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 141: _t->setCometsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 142: { Vec3f _r = _t->getCometsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 143: _t->setSednoidsOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 144: { Vec3f _r = _t->getSednoidsOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 145: _t->setInterstellarOrbitsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 146: { Vec3f _r = _t->getInterstellarOrbitsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 147: _t->setMercuryOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 148: { Vec3f _r = _t->getMercuryOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 149: _t->setVenusOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 150: { Vec3f _r = _t->getVenusOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 151: _t->setEarthOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 152: { Vec3f _r = _t->getEarthOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 153: _t->setMarsOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 154: { Vec3f _r = _t->getMarsOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 155: _t->setJupiterOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 156: { Vec3f _r = _t->getJupiterOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 157: _t->setSaturnOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 158: { Vec3f _r = _t->getSaturnOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 159: _t->setUranusOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 160: { Vec3f _r = _t->getUranusOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 161: _t->setNeptuneOrbitColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 162: { Vec3f _r = _t->getNeptuneOrbitColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 163: _t->setTrailsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 164: { Vec3f _r = _t->getTrailsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 165: _t->setPointerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 166: { Vec3f _r = _t->getPointerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 167: _t->setFlagMoonScale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 168: { bool _r = _t->getFlagMoonScale();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 169: _t->setMoonScale((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 170: { double _r = _t->getMoonScale();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 171: _t->setFlagDynamicMoonScale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 172: { bool _r = _t->getFlagDynamicMoonScale();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 173: _t->setMoonScaleMinFov((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 174: { double _r = _t->getMoonScaleMinFov();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 175: _t->setMoonScaleMaxFov((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 176: { double _r = _t->getMoonScaleMaxFov();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 177: _t->setFlagMinorBodyScale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 178: { bool _r = _t->getFlagMinorBodyScale();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 179: _t->setMinorBodyScale((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 180: { double _r = _t->getMinorBodyScale();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 181: _t->setFlagPlanetScale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 182: { bool _r = _t->getFlagPlanetScale();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 183: _t->setPlanetScale((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 184: { double _r = _t->getPlanetScale();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 185: _t->setFlagSunScale((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 186: { bool _r = _t->getFlagSunScale();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 187: _t->setSunScale((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 188: { double _r = _t->getSunScale();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 189: _t->updateI18n(); break;
        case 190: { float _r = _t->getPlanetVMagnitude((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 191: { float _r = _t->getPlanetVMagnitude((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 192: { QString _r = _t->getPlanetType((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 193: { double _r = _t->getDistanceToPlanet((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 194: { double _r = _t->getElongationForPlanet((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 195: { double _r = _t->getPhaseAngleForPlanet((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 196: { float _r = _t->getPhaseForPlanet((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 197: _t->setApparentMagnitudeAlgorithmOnEarth((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 198: _t->setApparentMagnitudeAlgorithmOnEarth((*reinterpret_cast<std::add_pointer_t<Planet::ApparentMagnitudeAlgorithm>>(_a[1]))); break;
        case 199: { QString _r = _t->getApparentMagnitudeAlgorithmOnEarth();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 200: _t->setFlagIsolatedTrails((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 201: { bool _r = _t->getFlagIsolatedTrails();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 202: _t->setNumberIsolatedTrails((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 203: { int _r = _t->getNumberIsolatedTrails();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 204: _t->setFlagIsolatedOrbits((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 205: { bool _r = _t->getFlagIsolatedOrbits();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 206: _t->setFlagPlanetsOrbits((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 207: { bool _r = _t->getFlagPlanetsOrbits();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 208: _t->setFlagPlanetsOrbitsOnly((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 209: { bool _r = _t->getFlagPlanetsOrbitsOnly();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 210: _t->setFlagOrbitsWithMoons((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 211: { bool _r = _t->getFlagOrbitsWithMoons();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 212: _t->setFlagPermanentSolarCorona((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 213: { bool _r = _t->getFlagPermanentSolarCorona();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 214: _t->setGrsLongitude((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 215: { int _r = _t->getGrsLongitude();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 216: _t->setGrsDrift((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 217: { double _r = _t->getGrsDrift();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 218: _t->setGrsJD((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 219: { double _r = _t->getGrsJD();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 220: _t->setFlagEarthShadowEnlargementDanjon((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 221: { bool _r = _t->getFlagEarthShadowEnlargementDanjon();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 222: _t->setOrbitColorStyle((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 223: { QString _r = _t->getOrbitColorStyle();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 224: { QStringList _r = _t->getObjectsList((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 225: { QStringList _r = _t->getObjectsList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 226: _t->setFlagPermanentOrbits((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 227: { bool _r = _t->getFlagPermanentOrbits();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 228: _t->setOrbitsThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 229: { int _r = _t->getOrbitsThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 230: _t->setFlagDrawMoonHalo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 231: { bool _r = _t->getFlagDrawMoonHalo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 232: _t->setFlagDrawSunHalo((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 233: { bool _r = _t->getFlagDrawSunHalo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 234: _t->reloadPlanets(); break;
        case 235: _t->recreateTrails(); break;
        case 236: _t->resetTextures((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 237: _t->setTextureForPlanet((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 238: { int _r = _t->getExtraThreads();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 239: _t->setExtraThreads((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 240: { double _r = _t->getMarkerMagThreshold();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 241: _t->setMarkerMagThreshold((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 242: _t->enableSurvey((*reinterpret_cast<std::add_pointer_t<HipsSurveyP>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<HipsSurveyP>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<HipsSurveyP>>(_a[3]))); break;
        case 243: _t->selectedObjectChange((*reinterpret_cast<std::add_pointer_t<StelModule::StelModuleSelectAction>>(_a[1]))); break;
        case 244: _t->updateSkyCulture((*reinterpret_cast<std::add_pointer_t<StelSkyCulture>>(_a[1]))); break;
        case 245: _t->loadCultureSpecificNames((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1]))); break;
        case 246: _t->reloadShaders(); break;
        case 247: _t->setFlagEphemerisMarkers((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 248: { bool _r = _t->getFlagEphemerisMarkers();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 249: _t->setFlagEphemerisLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 250: { bool _r = _t->getFlagEphemerisLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 251: _t->setFlagEphemerisAlwaysOn((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 252: { bool _r = _t->getFlagEphemerisAlwaysOn();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 253: _t->setFlagEphemerisNow((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 254: { bool _r = _t->getFlagEphemerisNow();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 255: _t->setEphemerisLineThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 256: { int _r = _t->getEphemerisLineThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 257: _t->setFlagEphemerisHorizontalCoordinates((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 258: { bool _r = _t->getFlagEphemerisHorizontalCoordinates();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 259: _t->setFlagEphemerisDates((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 260: { bool _r = _t->getFlagEphemerisDates();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 261: _t->setFlagEphemerisMagnitudes((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 262: { bool _r = _t->getFlagEphemerisMagnitudes();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 263: _t->setFlagEphemerisSkipData((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 264: { bool _r = _t->getFlagEphemerisSkipData();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 265: _t->setFlagEphemerisSkipMarkers((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 266: { bool _r = _t->getFlagEphemerisSkipMarkers();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 267: _t->setFlagEphemerisSmartDates((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 268: { bool _r = _t->getFlagEphemerisSmartDates();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 269: _t->setFlagEphemerisScaleMarkers((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 270: { bool _r = _t->getFlagEphemerisScaleMarkers();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 271: _t->setEphemerisDataStep((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 272: { int _r = _t->getEphemerisDataStep();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 273: _t->setEphemerisDataLimit((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 274: { int _r = _t->getEphemerisDataLimit();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 275: _t->setEphemerisGenericMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 276: { Vec3f _r = _t->getEphemerisGenericMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 277: _t->setEphemerisSecondaryMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 278: { Vec3f _r = _t->getEphemerisSecondaryMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 279: _t->setEphemerisSelectedMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 280: { Vec3f _r = _t->getEphemerisSelectedMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 281: _t->setEphemerisMercuryMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 282: { Vec3f _r = _t->getEphemerisMercuryMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 283: _t->setEphemerisVenusMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 284: { Vec3f _r = _t->getEphemerisVenusMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 285: _t->setEphemerisMarsMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 286: { Vec3f _r = _t->getEphemerisMarsMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 287: _t->setEphemerisJupiterMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 288: { Vec3f _r = _t->getEphemerisJupiterMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 289: _t->setEphemerisSaturnMarkerColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 290: { Vec3f _r = _t->getEphemerisSaturnMarkerColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 291: _t->fillEphemerisDates(); break;
        case 292: _t->reconfigureOrbits(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); 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 61:
            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 62:
            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 63:
            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 64:
            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 65:
            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 66:
            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 67:
            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 68:
            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 69:
            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 70:
            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 71:
            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 72:
            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 73:
            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 74:
            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 75:
            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 76:
            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 77:
            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 78:
            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 79:
            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 80:
            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 81:
            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 82:
            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 83:
            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 84:
            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 85:
            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 121:
            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 123:
            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 125:
            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 127:
            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 129:
            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 131:
            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 133:
            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 135:
            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 137:
            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 139:
            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 141:
            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 143:
            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 145:
            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 147:
            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 149:
            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 151:
            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 153:
            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 155:
            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 157:
            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 159:
            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 161:
            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 163:
            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 165:
            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 242:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 2:
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< HipsSurveyP >(); break;
            }
            break;
        case 243:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelModule::StelModuleSelectAction >(); break;
            }
            break;
        case 275:
            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 277:
            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 279:
            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 281:
            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 283:
            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 285:
            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 287:
            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 289:
            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 (SolarSystem::*)(bool )>(_a, &SolarSystem::labelsDisplayedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagOrbitsChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagHintsChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::markersDisplayedChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagDrawMoonHaloChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagDrawSunHaloChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::trailsDisplayedChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::trailsThicknessChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::orbitsThicknessChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::maxTrailPointsChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::maxTrailTimeExtentChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPointerChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPlanetsDisplayedChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPlanetsOrbitsChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPlanetsOrbitsOnlyChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPermanentOrbitsChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagIsolatedOrbitsChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagOrbitsWithMoonsChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagIsolatedTrailsChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::numberIsolatedTrailsChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagLightTravelTimeChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagUseObjModelsChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagShowObjSelfShadowsChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagMoonScaleChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::moonScaleChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagDynamicMoonScaleChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::moonScaleMinFovChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::moonScaleMaxFovChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagMinorBodyScaleChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::minorBodyScaleChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPlanetScaleChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::planetScaleChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagSunScaleChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::sunScaleChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::labelsAmountChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisMarkersChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisHorizontalCoordinatesChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisDatesChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisMagnitudesChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisLineChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisAlwaysOnChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisNowChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::ephemerisLineThicknessChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisSkipDataChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisSkipMarkersChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::ephemerisDataStepChanged, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::ephemerisDataLimitChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisSmartDatesChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::ephemerisScaleMarkersChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(int )>(_a, &SolarSystem::grsLongitudeChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::grsDriftChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::grsJDChanged, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::earthShadowEnlargementDanjonChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(bool )>(_a, &SolarSystem::flagPermanentSolarCoronaChanged, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::labelsColorChanged, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::pointerColorChanged, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::trailsColorChanged, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::orbitsColorChanged, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::nomenclatureColorChanged, 58))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::majorPlanetsOrbitsColorChanged, 59))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::minorPlanetsOrbitsColorChanged, 60))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::dwarfPlanetsOrbitsColorChanged, 61))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::moonsOrbitsColorChanged, 62))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::cubewanosOrbitsColorChanged, 63))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::plutinosOrbitsColorChanged, 64))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::scatteredDiskObjectsOrbitsColorChanged, 65))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::oortCloudObjectsOrbitsColorChanged, 66))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::cometsOrbitsColorChanged, 67))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::sednoidsOrbitsColorChanged, 68))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::interstellarOrbitsColorChanged, 69))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::mercuryOrbitColorChanged, 70))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::venusOrbitColorChanged, 71))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::earthOrbitColorChanged, 72))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::marsOrbitColorChanged, 73))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::jupiterOrbitColorChanged, 74))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::saturnOrbitColorChanged, 75))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::uranusOrbitColorChanged, 76))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::neptuneOrbitColorChanged, 77))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisGenericMarkerColorChanged, 78))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisSecondaryMarkerColorChanged, 79))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisSelectedMarkerColorChanged, 80))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisMercuryMarkerColorChanged, 81))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisVenusMarkerColorChanged, 82))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisMarsMarkerColorChanged, 83))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisJupiterMarkerColorChanged, 84))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const Vec3f & )>(_a, &SolarSystem::ephemerisSaturnMarkerColorChanged, 85))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const QString & )>(_a, &SolarSystem::orbitColorStyleChanged, 86))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const QString & )>(_a, &SolarSystem::apparentMagnitudeAlgorithmOnEarthChanged, 87))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)()>(_a, &SolarSystem::solarSystemDataReloaded, 88))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)()>(_a, &SolarSystem::requestEphemerisVisualization, 89))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(const int )>(_a, &SolarSystem::extraThreadsChanged, 90))
            return;
        if (QtMocHelpers::indexOfMethod<void (SolarSystem::*)(double )>(_a, &SolarSystem::markerMagThresholdChanged, 91))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 81:
        case 80:
        case 79:
        case 78:
        case 77:
        case 76:
        case 75:
        case 74:
        case 73:
        case 72:
        case 71:
        case 70:
        case 69:
        case 68:
        case 67:
        case 66:
        case 65:
        case 64:
        case 63:
        case 62:
        case 61:
        case 60:
        case 59:
        case 58:
        case 57:
        case 56:
        case 55:
        case 54:
        case 53:
        case 52:
        case 51:
            *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->getFlagLabels(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlagTrails(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->getMaxTrailPoints(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->getMaxTrailTimeExtent(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->getTrailsThickness(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->getFlagHints(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->getFlagMarkers(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getFlagPointer(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->getFlagPlanets(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->getFlagOrbits(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->getFlagPlanetsOrbits(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->getFlagPlanetsOrbitsOnly(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->getFlagPermanentOrbits(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getFlagIsolatedOrbits(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->getFlagOrbitsWithMoons(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->getFlagIsolatedTrails(); break;
        case 16: *reinterpret_cast<int*>(_v) = _t->getNumberIsolatedTrails(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->getFlagLightTravelTime(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->getFlagUseObjModels(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->getFlagShowObjSelfShadows(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->getFlagMoonScale(); break;
        case 21: *reinterpret_cast<double*>(_v) = _t->getMoonScale(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->getFlagDynamicMoonScale(); break;
        case 23: *reinterpret_cast<double*>(_v) = _t->getMoonScaleMinFov(); break;
        case 24: *reinterpret_cast<double*>(_v) = _t->getMoonScaleMaxFov(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->getFlagMinorBodyScale(); break;
        case 26: *reinterpret_cast<double*>(_v) = _t->getMinorBodyScale(); break;
        case 27: *reinterpret_cast<bool*>(_v) = _t->getFlagPlanetScale(); break;
        case 28: *reinterpret_cast<double*>(_v) = _t->getPlanetScale(); break;
        case 29: *reinterpret_cast<bool*>(_v) = _t->getFlagSunScale(); break;
        case 30: *reinterpret_cast<double*>(_v) = _t->getSunScale(); break;
        case 31: *reinterpret_cast<double*>(_v) = _t->getLabelsAmount(); break;
        case 32: *reinterpret_cast<bool*>(_v) = _t->getFlagPermanentSolarCorona(); break;
        case 33: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisMarkers(); break;
        case 34: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisHorizontalCoordinates(); break;
        case 35: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisDates(); break;
        case 36: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisMagnitudes(); break;
        case 37: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisLine(); break;
        case 38: *reinterpret_cast<int*>(_v) = _t->getEphemerisLineThickness(); break;
        case 39: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisSkipData(); break;
        case 40: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisSkipMarkers(); break;
        case 41: *reinterpret_cast<int*>(_v) = _t->getEphemerisDataStep(); break;
        case 42: *reinterpret_cast<int*>(_v) = _t->getEphemerisDataLimit(); break;
        case 43: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisSmartDates(); break;
        case 44: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisScaleMarkers(); break;
        case 45: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisAlwaysOn(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->getFlagEphemerisNow(); break;
        case 47: *reinterpret_cast<int*>(_v) = _t->getGrsLongitude(); break;
        case 48: *reinterpret_cast<double*>(_v) = _t->getGrsDrift(); break;
        case 49: *reinterpret_cast<double*>(_v) = _t->getGrsJD(); break;
        case 50: *reinterpret_cast<bool*>(_v) = _t->getFlagEarthShadowEnlargementDanjon(); break;
        case 51: *reinterpret_cast<Vec3f*>(_v) = _t->getLabelsColor(); break;
        case 52: *reinterpret_cast<Vec3f*>(_v) = _t->getPointerColor(); break;
        case 53: *reinterpret_cast<Vec3f*>(_v) = _t->getTrailsColor(); break;
        case 54: *reinterpret_cast<Vec3f*>(_v) = _t->getOrbitsColor(); break;
        case 55: *reinterpret_cast<Vec3f*>(_v) = _t->getMajorPlanetsOrbitsColor(); break;
        case 56: *reinterpret_cast<Vec3f*>(_v) = _t->getMinorPlanetsOrbitsColor(); break;
        case 57: *reinterpret_cast<Vec3f*>(_v) = _t->getDwarfPlanetsOrbitsColor(); break;
        case 58: *reinterpret_cast<Vec3f*>(_v) = _t->getMoonsOrbitsColor(); break;
        case 59: *reinterpret_cast<Vec3f*>(_v) = _t->getCubewanosOrbitsColor(); break;
        case 60: *reinterpret_cast<Vec3f*>(_v) = _t->getPlutinosOrbitsColor(); break;
        case 61: *reinterpret_cast<Vec3f*>(_v) = _t->getScatteredDiskObjectsOrbitsColor(); break;
        case 62: *reinterpret_cast<Vec3f*>(_v) = _t->getOortCloudObjectsOrbitsColor(); break;
        case 63: *reinterpret_cast<Vec3f*>(_v) = _t->getCometsOrbitsColor(); break;
        case 64: *reinterpret_cast<Vec3f*>(_v) = _t->getSednoidsOrbitsColor(); break;
        case 65: *reinterpret_cast<Vec3f*>(_v) = _t->getInterstellarOrbitsColor(); break;
        case 66: *reinterpret_cast<Vec3f*>(_v) = _t->getMercuryOrbitColor(); break;
        case 67: *reinterpret_cast<Vec3f*>(_v) = _t->getVenusOrbitColor(); break;
        case 68: *reinterpret_cast<Vec3f*>(_v) = _t->getEarthOrbitColor(); break;
        case 69: *reinterpret_cast<Vec3f*>(_v) = _t->getMarsOrbitColor(); break;
        case 70: *reinterpret_cast<Vec3f*>(_v) = _t->getJupiterOrbitColor(); break;
        case 71: *reinterpret_cast<Vec3f*>(_v) = _t->getSaturnOrbitColor(); break;
        case 72: *reinterpret_cast<Vec3f*>(_v) = _t->getUranusOrbitColor(); break;
        case 73: *reinterpret_cast<Vec3f*>(_v) = _t->getNeptuneOrbitColor(); break;
        case 74: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisGenericMarkerColor(); break;
        case 75: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisSecondaryMarkerColor(); break;
        case 76: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisSelectedMarkerColor(); break;
        case 77: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisMercuryMarkerColor(); break;
        case 78: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisVenusMarkerColor(); break;
        case 79: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisMarsMarkerColor(); break;
        case 80: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisJupiterMarkerColor(); break;
        case 81: *reinterpret_cast<Vec3f*>(_v) = _t->getEphemerisSaturnMarkerColor(); break;
        case 82: *reinterpret_cast<QString*>(_v) = _t->getOrbitColorStyle(); break;
        case 83: *reinterpret_cast<QString*>(_v) = _t->getApparentMagnitudeAlgorithmOnEarth(); break;
        case 84: *reinterpret_cast<int*>(_v) = _t->getOrbitsThickness(); break;
        case 85: *reinterpret_cast<bool*>(_v) = _t->getFlagDrawMoonHalo(); break;
        case 86: *reinterpret_cast<bool*>(_v) = _t->getFlagDrawSunHalo(); break;
        case 87: *reinterpret_cast<int*>(_v) = _t->getExtraThreads(); break;
        case 88: *reinterpret_cast<double*>(_v) = _t->getMarkerMagThreshold(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagLabels(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlagTrails(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setMaxTrailPoints(*reinterpret_cast<int*>(_v)); break;
        case 3: _t->setMaxTrailTimeExtent(*reinterpret_cast<int*>(_v)); break;
        case 4: _t->setTrailsThickness(*reinterpret_cast<int*>(_v)); break;
        case 5: _t->setFlagHints(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setFlagMarkers(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setFlagPointer(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setFlagPlanets(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setFlagOrbits(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setFlagPlanetsOrbits(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setFlagPlanetsOrbitsOnly(*reinterpret_cast<bool*>(_v)); break;
        case 12: _t->setFlagPermanentOrbits(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->setFlagIsolatedOrbits(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setFlagOrbitsWithMoons(*reinterpret_cast<bool*>(_v)); break;
        case 15: _t->setFlagIsolatedTrails(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setNumberIsolatedTrails(*reinterpret_cast<int*>(_v)); break;
        case 17: _t->setFlagLightTravelTime(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setFlagUseObjModels(*reinterpret_cast<bool*>(_v)); break;
        case 19: _t->setFlagShowObjSelfShadows(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setFlagMoonScale(*reinterpret_cast<bool*>(_v)); break;
        case 21: _t->setMoonScale(*reinterpret_cast<double*>(_v)); break;
        case 22: _t->setFlagDynamicMoonScale(*reinterpret_cast<bool*>(_v)); break;
        case 23: _t->setMoonScaleMinFov(*reinterpret_cast<double*>(_v)); break;
        case 24: _t->setMoonScaleMaxFov(*reinterpret_cast<double*>(_v)); break;
        case 25: _t->setFlagMinorBodyScale(*reinterpret_cast<bool*>(_v)); break;
        case 26: _t->setMinorBodyScale(*reinterpret_cast<double*>(_v)); break;
        case 27: _t->setFlagPlanetScale(*reinterpret_cast<bool*>(_v)); break;
        case 28: _t->setPlanetScale(*reinterpret_cast<double*>(_v)); break;
        case 29: _t->setFlagSunScale(*reinterpret_cast<bool*>(_v)); break;
        case 30: _t->setSunScale(*reinterpret_cast<double*>(_v)); break;
        case 31: _t->setLabelsAmount(*reinterpret_cast<double*>(_v)); break;
        case 32: _t->setFlagPermanentSolarCorona(*reinterpret_cast<bool*>(_v)); break;
        case 33: _t->setFlagEphemerisMarkers(*reinterpret_cast<bool*>(_v)); break;
        case 34: _t->setFlagEphemerisHorizontalCoordinates(*reinterpret_cast<bool*>(_v)); break;
        case 35: _t->setFlagEphemerisDates(*reinterpret_cast<bool*>(_v)); break;
        case 36: _t->setFlagEphemerisMagnitudes(*reinterpret_cast<bool*>(_v)); break;
        case 37: _t->setFlagEphemerisLine(*reinterpret_cast<bool*>(_v)); break;
        case 38: _t->setEphemerisLineThickness(*reinterpret_cast<int*>(_v)); break;
        case 39: _t->setFlagEphemerisSkipData(*reinterpret_cast<bool*>(_v)); break;
        case 40: _t->setFlagEphemerisSkipMarkers(*reinterpret_cast<bool*>(_v)); break;
        case 41: _t->setEphemerisDataStep(*reinterpret_cast<int*>(_v)); break;
        case 42: _t->setEphemerisDataLimit(*reinterpret_cast<int*>(_v)); break;
        case 43: _t->setFlagEphemerisSmartDates(*reinterpret_cast<bool*>(_v)); break;
        case 44: _t->setFlagEphemerisScaleMarkers(*reinterpret_cast<bool*>(_v)); break;
        case 45: _t->setFlagEphemerisAlwaysOn(*reinterpret_cast<bool*>(_v)); break;
        case 46: _t->setFlagEphemerisNow(*reinterpret_cast<bool*>(_v)); break;
        case 47: _t->setGrsLongitude(*reinterpret_cast<int*>(_v)); break;
        case 48: _t->setGrsDrift(*reinterpret_cast<double*>(_v)); break;
        case 49: _t->setGrsJD(*reinterpret_cast<double*>(_v)); break;
        case 50: _t->setFlagEarthShadowEnlargementDanjon(*reinterpret_cast<bool*>(_v)); break;
        case 51: _t->setLabelsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 52: _t->setPointerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 53: _t->setTrailsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 54: _t->setOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 55: _t->setMajorPlanetsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 56: _t->setMinorPlanetsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 57: _t->setDwarfPlanetsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 58: _t->setMoonsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 59: _t->setCubewanosOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 60: _t->setPlutinosOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 61: _t->setScatteredDiskObjectsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 62: _t->setOortCloudObjectsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 63: _t->setCometsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 64: _t->setSednoidsOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 65: _t->setInterstellarOrbitsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 66: _t->setMercuryOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 67: _t->setVenusOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 68: _t->setEarthOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 69: _t->setMarsOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 70: _t->setJupiterOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 71: _t->setSaturnOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 72: _t->setUranusOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 73: _t->setNeptuneOrbitColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 74: _t->setEphemerisGenericMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 75: _t->setEphemerisSecondaryMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 76: _t->setEphemerisSelectedMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 77: _t->setEphemerisMercuryMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 78: _t->setEphemerisVenusMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 79: _t->setEphemerisMarsMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 80: _t->setEphemerisJupiterMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 81: _t->setEphemerisSaturnMarkerColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 82: _t->setOrbitColorStyle(*reinterpret_cast<QString*>(_v)); break;
        case 83: _t->setApparentMagnitudeAlgorithmOnEarth(*reinterpret_cast<QString*>(_v)); break;
        case 84: _t->setOrbitsThickness(*reinterpret_cast<int*>(_v)); break;
        case 85: _t->setFlagDrawMoonHalo(*reinterpret_cast<bool*>(_v)); break;
        case 86: _t->setFlagDrawSunHalo(*reinterpret_cast<bool*>(_v)); break;
        case 87: _t->setExtraThreads(*reinterpret_cast<int*>(_v)); break;
        case 88: _t->setMarkerMagThreshold(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}

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

void *SolarSystem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11SolarSystemE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "QOpenGLFunctions"))
        return static_cast< QOpenGLFunctions*>(this);
    return StelObjectModule::qt_metacast(_clname);
}

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

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

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

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

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

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

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

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

// SIGNAL 7
void SolarSystem::trailsThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void SolarSystem::orbitsThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void SolarSystem::maxTrailPointsChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void SolarSystem::maxTrailTimeExtentChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

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

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

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

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

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

// SIGNAL 16
void SolarSystem::flagIsolatedOrbitsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void SolarSystem::flagOrbitsWithMoonsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

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

// SIGNAL 19
void SolarSystem::numberIsolatedTrailsChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void SolarSystem::flagLightTravelTimeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void SolarSystem::flagUseObjModelsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void SolarSystem::flagShowObjSelfShadowsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void SolarSystem::flagMoonScaleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

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

// SIGNAL 25
void SolarSystem::flagDynamicMoonScaleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void SolarSystem::moonScaleMinFovChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void SolarSystem::moonScaleMaxFovChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void SolarSystem::flagMinorBodyScaleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

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

// SIGNAL 30
void SolarSystem::flagPlanetScaleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void SolarSystem::planetScaleChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void SolarSystem::flagSunScaleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void SolarSystem::sunScaleChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void SolarSystem::labelsAmountChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void SolarSystem::ephemerisMarkersChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void SolarSystem::ephemerisHorizontalCoordinatesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void SolarSystem::ephemerisDatesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void SolarSystem::ephemerisMagnitudesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void SolarSystem::ephemerisLineChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void SolarSystem::ephemerisAlwaysOnChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void SolarSystem::ephemerisNowChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void SolarSystem::ephemerisLineThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void SolarSystem::ephemerisSkipDataChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 43, nullptr, _t1);
}

// SIGNAL 44
void SolarSystem::ephemerisSkipMarkersChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void SolarSystem::ephemerisDataStepChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1);
}

// SIGNAL 46
void SolarSystem::ephemerisDataLimitChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void SolarSystem::ephemerisSmartDatesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 47, nullptr, _t1);
}

// SIGNAL 48
void SolarSystem::ephemerisScaleMarkersChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void SolarSystem::grsLongitudeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1);
}

// SIGNAL 50
void SolarSystem::grsDriftChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 50, nullptr, _t1);
}

// SIGNAL 51
void SolarSystem::grsJDChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 51, nullptr, _t1);
}

// SIGNAL 52
void SolarSystem::earthShadowEnlargementDanjonChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void SolarSystem::flagPermanentSolarCoronaChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 53, nullptr, _t1);
}

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

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

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

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

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

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

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

// SIGNAL 61
void SolarSystem::dwarfPlanetsOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 61, nullptr, _t1);
}

// SIGNAL 62
void SolarSystem::moonsOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 62, nullptr, _t1);
}

// SIGNAL 63
void SolarSystem::cubewanosOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 63, nullptr, _t1);
}

// SIGNAL 64
void SolarSystem::plutinosOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 64, nullptr, _t1);
}

// SIGNAL 65
void SolarSystem::scatteredDiskObjectsOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 65, nullptr, _t1);
}

// SIGNAL 66
void SolarSystem::oortCloudObjectsOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 66, nullptr, _t1);
}

// SIGNAL 67
void SolarSystem::cometsOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 67, nullptr, _t1);
}

// SIGNAL 68
void SolarSystem::sednoidsOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 68, nullptr, _t1);
}

// SIGNAL 69
void SolarSystem::interstellarOrbitsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 69, nullptr, _t1);
}

// SIGNAL 70
void SolarSystem::mercuryOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 70, nullptr, _t1);
}

// SIGNAL 71
void SolarSystem::venusOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 71, nullptr, _t1);
}

// SIGNAL 72
void SolarSystem::earthOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 72, nullptr, _t1);
}

// SIGNAL 73
void SolarSystem::marsOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 73, nullptr, _t1);
}

// SIGNAL 74
void SolarSystem::jupiterOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 74, nullptr, _t1);
}

// SIGNAL 75
void SolarSystem::saturnOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 75, nullptr, _t1);
}

// SIGNAL 76
void SolarSystem::uranusOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 76, nullptr, _t1);
}

// SIGNAL 77
void SolarSystem::neptuneOrbitColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 77, nullptr, _t1);
}

// SIGNAL 78
void SolarSystem::ephemerisGenericMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 78, nullptr, _t1);
}

// SIGNAL 79
void SolarSystem::ephemerisSecondaryMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 79, nullptr, _t1);
}

// SIGNAL 80
void SolarSystem::ephemerisSelectedMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 80, nullptr, _t1);
}

// SIGNAL 81
void SolarSystem::ephemerisMercuryMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 81, nullptr, _t1);
}

// SIGNAL 82
void SolarSystem::ephemerisVenusMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 82, nullptr, _t1);
}

// SIGNAL 83
void SolarSystem::ephemerisMarsMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 83, nullptr, _t1);
}

// SIGNAL 84
void SolarSystem::ephemerisJupiterMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 84, nullptr, _t1);
}

// SIGNAL 85
void SolarSystem::ephemerisSaturnMarkerColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 85, nullptr, _t1);
}

// SIGNAL 86
void SolarSystem::orbitColorStyleChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 86, nullptr, _t1);
}

// SIGNAL 87
void SolarSystem::apparentMagnitudeAlgorithmOnEarthChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 87, nullptr, _t1);
}

// SIGNAL 88
void SolarSystem::solarSystemDataReloaded()
{
    QMetaObject::activate(this, &staticMetaObject, 88, nullptr);
}

// SIGNAL 89
void SolarSystem::requestEphemerisVisualization()
{
    QMetaObject::activate(this, &staticMetaObject, 89, nullptr);
}

// SIGNAL 90
void SolarSystem::extraThreadsChanged(const int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 90, nullptr, _t1);
}

// SIGNAL 91
void SolarSystem::markerMagThresholdChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 91, nullptr, _t1);
}
QT_WARNING_POP
