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

template <> constexpr inline auto StelCore::qt_create_metaobjectdata<qt_meta_tag_ZN8StelCoreE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StelCore",
        "locationChanged",
        "",
        "StelLocation",
        "targetLocationChanged",
        "loc",
        "id",
        "currentTimeZoneChanged",
        "tz",
        "useCustomTimeZoneChanged",
        "b",
        "flagUseDSTChanged",
        "startupTimeStopChanged",
        "timeRateChanged",
        "rate",
        "timeSyncOccurred",
        "jDay",
        "dateChanged",
        "dateChangedForTrails",
        "dateChangedForMonth",
        "dateChangedByYear",
        "year",
        "flipHorzChanged",
        "flipVertChanged",
        "flagUseNutationChanged",
        "flagUseAberrationChanged",
        "aberrationFactorChanged",
        "val",
        "flagUseParallaxChanged",
        "parallaxFactorChanged",
        "flagUseTopocentricCoordinatesChanged",
        "currentProjectionTypeChanged",
        "StelCore::ProjectionType",
        "newType",
        "currentProjectionTypeKeyChanged",
        "newValue",
        "currentProjectionNameI18nChanged",
        "flagGravityLabelsChanged",
        "gravity",
        "configurationDataSaved",
        "updateSearchLists",
        "ditheringModeChanged",
        "DitheringMode",
        "mode",
        "ephemAlgorithmChanged",
        "moveObserverTo",
        "target",
        "duration",
        "durationIfPlanetChange",
        "landscapeID",
        "setCurrentProjectionType",
        "type",
        "getCurrentProjectionType",
        "getCurrentProjectionTypeKey",
        "setCurrentProjectionTypeKey",
        "getCurrentProjectionNameI18n",
        "getAllProjectionTypeKeys",
        "setCurrentDeltaTAlgorithm",
        "StelCore::DeltaTAlgorithm",
        "algorithm",
        "getCurrentDeltaTAlgorithm",
        "getCurrentDeltaTAlgorithmDescription",
        "getCurrentDeltaTAlgorithmKey",
        "setCurrentDeltaTAlgorithmKey",
        "setMaskType",
        "StelProjector::StelProjectorMaskType",
        "m",
        "setFlagGravityLabels",
        "getFlagGravityLabels",
        "setDefaultAngleForGravityText",
        "a",
        "setFlipHorz",
        "flip",
        "setFlipVert",
        "getFlipHorz",
        "getFlipVert",
        "getViewportHorizontalOffset",
        "setViewportHorizontalOffset",
        "newOffsetPct",
        "getViewportVerticalOffset",
        "setViewportVerticalOffset",
        "setViewportOffset",
        "newHorizontalOffsetPct",
        "newVerticalOffsetPct",
        "setViewportStretch",
        "stretch",
        "getDefaultLocationID",
        "setDefaultLocationID",
        "returnToDefaultLocation",
        "returnToHome",
        "getJDOfLastJDUpdate",
        "setMilliSecondsOfLastJDUpdate",
        "millis",
        "getMilliSecondsOfLastJDUpdate",
        "setJD",
        "newJD",
        "setJDE",
        "newJDE",
        "getJD",
        "getJDE",
        "getSolutionEquationOfTime",
        "JDE",
        "getUseDST",
        "setUseDST",
        "getStartupTimeStop",
        "setStartupTimeStop",
        "getDitheringMode",
        "setDitheringMode",
        "modeName",
        "getUseCustomTimeZone",
        "setUseCustomTimeZone",
        "setMJDay",
        "MJD",
        "getMJDay",
        "computeDeltaT",
        "JD",
        "getDeltaT",
        "getUseNutation",
        "setUseNutation",
        "use",
        "getUseAberration",
        "setUseAberration",
        "getAberrationFactor",
        "setAberrationFactor",
        "factor",
        "getAberrationShader",
        "setAberrationUniforms",
        "QOpenGLShaderProgram&",
        "program",
        "getUseParallax",
        "setUseParallax",
        "getParallaxFactor",
        "setParallaxFactor",
        "getUseTopocentricCoordinates",
        "setUseTopocentricCoordinates",
        "getPresetSkyTime",
        "setPresetSkyTime",
        "d",
        "setTimeRate",
        "ts",
        "getTimeRate",
        "toggleTimeSpeed",
        "revertTimeDirection",
        "increaseTimeSpeed",
        "decreaseTimeSpeed",
        "increaseTimeSpeedLess",
        "decreaseTimeSpeedLess",
        "setZeroTimeSpeed",
        "setRealTimeSpeed",
        "toggleRealTimeSpeed",
        "getRealTimeSpeed",
        "setTimeNow",
        "setTodayTime",
        "getIsTimeNow",
        "getInitTodayTime",
        "setInitTodayTime",
        "time",
        "dateTime",
        "addMinute",
        "addHour",
        "addDay",
        "addWeek",
        "addSiderealDay",
        "addSiderealWeek",
        "addSiderealYear",
        "addSiderealYears",
        "n",
        "subtractMinute",
        "subtractHour",
        "subtractDay",
        "subtractWeek",
        "subtractSiderealDay",
        "subtractSiderealWeek",
        "subtractSiderealYear",
        "subtractSiderealYears",
        "addSynodicMonth",
        "addMetonicCycle",
        "addSaros",
        "addDraconicYear",
        "addDraconicMonth",
        "addAnomalisticMonth",
        "addAnomalisticYear",
        "addAnomalisticYears",
        "addMeanTropicalMonth",
        "addMeanTropicalYear",
        "addMeanTropicalYears",
        "addTropicalYear",
        "addGreatYear",
        "addCalendarMonth",
        "addCalendarYear",
        "addCalendarDecade",
        "addCalendarCentury",
        "addJulianYear",
        "addJulianYears",
        "addGaussianYear",
        "subtractSynodicMonth",
        "subtractMetonicCycle",
        "subtractSaros",
        "subtractDraconicYear",
        "subtractDraconicMonth",
        "subtractAnomalisticMonth",
        "subtractAnomalisticYear",
        "subtractAnomalisticYears",
        "subtractMeanTropicalMonth",
        "subtractMeanTropicalYear",
        "subtractMeanTropicalYears",
        "subtractTropicalYear",
        "subtractGreatYear",
        "subtractCalendarMonth",
        "subtractCalendarYear",
        "subtractCalendarDecade",
        "subtractCalendarCentury",
        "subtractJulianYear",
        "subtractJulianYears",
        "subtractGaussianYear",
        "addSolarDays",
        "addSiderealDays",
        "moveObserverToSelected",
        "setDeltaTCustomYear",
        "y",
        "setDeltaTCustomNDot",
        "v",
        "setDeltaTCustomEquationCoefficients",
        "Vec3d",
        "c",
        "getDeltaTCustomYear",
        "getDeltaTCustomNDot",
        "getDeltaTnDot",
        "getDeltaTCustomEquationCoefficients",
        "initEphemeridesFunctions",
        "de430IsAvailable",
        "de431IsAvailable",
        "de430IsActive",
        "de431IsActive",
        "setDe430Active",
        "status",
        "setDe431Active",
        "de440IsAvailable",
        "de441IsAvailable",
        "de440IsActive",
        "de441IsActive",
        "setDe440Active",
        "setDe441Active",
        "setMinMaxEphemRange",
        "std::pair<int,int>",
        "mm",
        "getMinMaxEphemRange",
        "getIAUConstellation",
        "positionEqJnow",
        "luminanceToNELM",
        "luminance",
        "nelmToLuminance",
        "nelm",
        "bortleScaleIndexToNELM",
        "index",
        "bortleScaleIndexToLuminance",
        "nelmToBortleScaleIndex",
        "luminanceToBortleScaleIndex",
        "luminanceToMPSAS",
        "cdm2",
        "mpsasToLuminance",
        "mag",
        "updateFixedEquatorialTransformMatrices",
        "flipHorz",
        "flipVert",
        "flagUseNutation",
        "flagUseAberration",
        "aberrationFactor",
        "flagUseParallax",
        "parallaxFactor",
        "flagUseTopocentricCoordinates",
        "currentProjectionType",
        "ProjectionType",
        "currentProjectionTypeKey",
        "currentProjectionNameI18n",
        "flagGravityLabels",
        "currentTimeZone",
        "flagUseCTZ",
        "flagUseDST",
        "startupTimeStop",
        "ditheringMode",
        "FrameType",
        "FrameUninitialized",
        "FrameAltAz",
        "FrameHeliocentricEclipticJ2000",
        "FrameObservercentricEclipticJ2000",
        "FrameObservercentricEclipticOfDate",
        "FrameEquinoxEqu",
        "FrameJ2000",
        "FrameFixedEquatorial",
        "FrameGalactic",
        "FrameSupergalactic",
        "ProjectionPerspective",
        "ProjectionStereographic",
        "ProjectionFisheye",
        "ProjectionOrthographic",
        "ProjectionEqualArea",
        "ProjectionHammer",
        "ProjectionMollweide",
        "ProjectionSinusoidal",
        "ProjectionMercator",
        "ProjectionMiller",
        "ProjectionCylinder",
        "ProjectionCylinderFill",
        "RefractionMode",
        "RefractionAuto",
        "RefractionOn",
        "RefractionOff",
        "DeltaTAlgorithm",
        "WithoutCorrection",
        "Schoch",
        "Clemence",
        "IAU",
        "AstronomicalEphemeris",
        "TuckermanGoldstine",
        "MullerStephenson",
        "Stephenson1978",
        "SchmadelZech1979",
        "MorrisonStephenson1982",
        "StephensonMorrison1984",
        "StephensonHoulden",
        "Espenak",
        "Borkowski",
        "SchmadelZech1988",
        "ChaprontTouze",
        "StephensonMorrison1995",
        "Stephenson1997",
        "ChaprontMeeus",
        "JPLHorizons",
        "MeeusSimons",
        "MontenbruckPfleger",
        "ReingoldDershowitz",
        "MorrisonStephenson2004",
        "Reijs",
        "EspenakMeeus",
        "EspenakMeeusModified",
        "EspenakMeeusZeroMoonAccel",
        "Banjevic",
        "IslamSadiqQureshi",
        "KhalidSultanaZaidi",
        "StephensonMorrisonHohenkerk2016",
        "Henriksson2017",
        "Custom"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'locationChanged'
        QtMocHelpers::SignalData<void(const StelLocation &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'targetLocationChanged'
        QtMocHelpers::SignalData<void(const StelLocation &, const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 5 }, { QMetaType::QString, 6 },
        }}),
        // Signal 'currentTimeZoneChanged'
        QtMocHelpers::SignalData<void(const QString &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Signal 'useCustomTimeZoneChanged'
        QtMocHelpers::SignalData<void(const bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'flagUseDSTChanged'
        QtMocHelpers::SignalData<void(const bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'startupTimeStopChanged'
        QtMocHelpers::SignalData<void(const bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'timeRateChanged'
        QtMocHelpers::SignalData<void(double)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 14 },
        }}),
        // Signal 'timeSyncOccurred'
        QtMocHelpers::SignalData<void(double)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 16 },
        }}),
        // Signal 'dateChanged'
        QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dateChangedForTrails'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dateChangedForMonth'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dateChangedByYear'
        QtMocHelpers::SignalData<void(const int)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 21 },
        }}),
        // Signal 'flipHorzChanged'
        QtMocHelpers::SignalData<void(bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'flipVertChanged'
        QtMocHelpers::SignalData<void(bool)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'flagUseNutationChanged'
        QtMocHelpers::SignalData<void(bool)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'flagUseAberrationChanged'
        QtMocHelpers::SignalData<void(bool)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'aberrationFactorChanged'
        QtMocHelpers::SignalData<void(double)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 27 },
        }}),
        // Signal 'flagUseParallaxChanged'
        QtMocHelpers::SignalData<void(bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'parallaxFactorChanged'
        QtMocHelpers::SignalData<void(double)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 27 },
        }}),
        // Signal 'flagUseTopocentricCoordinatesChanged'
        QtMocHelpers::SignalData<void(bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Signal 'currentProjectionTypeChanged'
        QtMocHelpers::SignalData<void(StelCore::ProjectionType)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 33 },
        }}),
        // Signal 'currentProjectionTypeKeyChanged'
        QtMocHelpers::SignalData<void(const QString &)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Signal 'currentProjectionNameI18nChanged'
        QtMocHelpers::SignalData<void(const QString &)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Signal 'flagGravityLabelsChanged'
        QtMocHelpers::SignalData<void(bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 38 },
        }}),
        // Signal 'configurationDataSaved'
        QtMocHelpers::SignalData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateSearchLists'
        QtMocHelpers::SignalData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ditheringModeChanged'
        QtMocHelpers::SignalData<void(DitheringMode)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 43 },
        }}),
        // Signal 'ephemAlgorithmChanged'
        QtMocHelpers::SignalData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'moveObserverTo'
        QtMocHelpers::SlotData<void(const StelLocation &, double, double, const QString &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 46 }, { QMetaType::Double, 47 }, { QMetaType::Double, 48 }, { QMetaType::QString, 49 },
        }}),
        // Slot 'moveObserverTo'
        QtMocHelpers::SlotData<void(const StelLocation &, double, double)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 46 }, { QMetaType::Double, 47 }, { QMetaType::Double, 48 },
        }}),
        // Slot 'moveObserverTo'
        QtMocHelpers::SlotData<void(const StelLocation &, double)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 46 }, { QMetaType::Double, 47 },
        }}),
        // Slot 'moveObserverTo'
        QtMocHelpers::SlotData<void(const StelLocation &)>(45, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 3, 46 },
        }}),
        // Slot 'setCurrentProjectionType'
        QtMocHelpers::SlotData<void(StelCore::ProjectionType)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 51 },
        }}),
        // Slot 'getCurrentProjectionType'
        QtMocHelpers::SlotData<StelCore::ProjectionType() const>(52, 2, QMC::AccessPublic, 0x80000000 | 32),
        // Slot 'getCurrentProjectionTypeKey'
        QtMocHelpers::SlotData<QString() const>(53, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setCurrentProjectionTypeKey'
        QtMocHelpers::SlotData<void(QString)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 51 },
        }}),
        // Slot 'getCurrentProjectionNameI18n'
        QtMocHelpers::SlotData<QString() const>(55, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getAllProjectionTypeKeys'
        QtMocHelpers::SlotData<QStringList() const>(56, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'setCurrentDeltaTAlgorithm'
        QtMocHelpers::SlotData<void(StelCore::DeltaTAlgorithm)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 59 },
        }}),
        // Slot 'getCurrentDeltaTAlgorithm'
        QtMocHelpers::SlotData<StelCore::DeltaTAlgorithm() const>(60, 2, QMC::AccessPublic, 0x80000000 | 58),
        // Slot 'getCurrentDeltaTAlgorithmDescription'
        QtMocHelpers::SlotData<QString() const>(61, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getCurrentDeltaTAlgorithmKey'
        QtMocHelpers::SlotData<QString() const>(62, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setCurrentDeltaTAlgorithmKey'
        QtMocHelpers::SlotData<void(QString)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 51 },
        }}),
        // Slot 'setMaskType'
        QtMocHelpers::SlotData<void(StelProjector::StelProjectorMaskType)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 65, 66 },
        }}),
        // Slot 'setFlagGravityLabels'
        QtMocHelpers::SlotData<void(bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 38 },
        }}),
        // Slot 'getFlagGravityLabels'
        QtMocHelpers::SlotData<bool() const>(68, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setDefaultAngleForGravityText'
        QtMocHelpers::SlotData<void(float)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 70 },
        }}),
        // Slot 'setFlipHorz'
        QtMocHelpers::SlotData<void(bool)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 72 },
        }}),
        // Slot 'setFlipVert'
        QtMocHelpers::SlotData<void(bool)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 72 },
        }}),
        // Slot 'getFlipHorz'
        QtMocHelpers::SlotData<bool() const>(74, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getFlipVert'
        QtMocHelpers::SlotData<bool() const>(75, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getViewportHorizontalOffset'
        QtMocHelpers::SlotData<double() const>(76, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setViewportHorizontalOffset'
        QtMocHelpers::SlotData<void(double)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 78 },
        }}),
        // Slot 'getViewportVerticalOffset'
        QtMocHelpers::SlotData<double() const>(79, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setViewportVerticalOffset'
        QtMocHelpers::SlotData<void(double)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 78 },
        }}),
        // Slot 'setViewportOffset'
        QtMocHelpers::SlotData<void(double, double)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 82 }, { QMetaType::Double, 83 },
        }}),
        // Slot 'setViewportStretch'
        QtMocHelpers::SlotData<void(float)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 85 },
        }}),
        // Slot 'getDefaultLocationID'
        QtMocHelpers::SlotData<QString() const>(86, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setDefaultLocationID'
        QtMocHelpers::SlotData<void(const QString &)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'returnToDefaultLocation'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'returnToHome'
        QtMocHelpers::SlotData<void()>(89, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getJDOfLastJDUpdate'
        QtMocHelpers::SlotData<double() const>(90, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMilliSecondsOfLastJDUpdate'
        QtMocHelpers::SlotData<void(qint64)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::LongLong, 92 },
        }}),
        // Slot 'getMilliSecondsOfLastJDUpdate'
        QtMocHelpers::SlotData<qint64() const>(93, 2, QMC::AccessPublic, QMetaType::LongLong),
        // Slot 'setJD'
        QtMocHelpers::SlotData<void(double)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 95 },
        }}),
        // Slot 'setJDE'
        QtMocHelpers::SlotData<void(double)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 97 },
        }}),
        // Slot 'getJD'
        QtMocHelpers::SlotData<double() const>(98, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getJDE'
        QtMocHelpers::SlotData<double() const>(99, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getSolutionEquationOfTime'
        QtMocHelpers::SlotData<double(const double) const>(100, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 101 },
        }}),
        // Slot 'getSolutionEquationOfTime'
        QtMocHelpers::SlotData<double() const>(100, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getUseDST'
        QtMocHelpers::SlotData<bool() const>(102, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseDST'
        QtMocHelpers::SlotData<void(const bool)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Slot 'getStartupTimeStop'
        QtMocHelpers::SlotData<bool() const>(104, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setStartupTimeStop'
        QtMocHelpers::SlotData<void(const bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Slot 'getDitheringMode'
        QtMocHelpers::SlotData<DitheringMode() const>(106, 2, QMC::AccessPublic, 0x80000000 | 42),
        // Slot 'setDitheringMode'
        QtMocHelpers::SlotData<void(DitheringMode)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 43 },
        }}),
        // Slot 'setDitheringMode'
        QtMocHelpers::SlotData<void(const QString &)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 108 },
        }}),
        // Slot 'getUseCustomTimeZone'
        QtMocHelpers::SlotData<bool() const>(109, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseCustomTimeZone'
        QtMocHelpers::SlotData<void(const bool)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 10 },
        }}),
        // Slot 'setMJDay'
        QtMocHelpers::SlotData<void(double)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 112 },
        }}),
        // Slot 'getMJDay'
        QtMocHelpers::SlotData<double() const>(113, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'computeDeltaT'
        QtMocHelpers::SlotData<double(const double)>(114, 2, QMC::AccessPublic, QMetaType::Double, {{
            { QMetaType::Double, 115 },
        }}),
        // Slot 'getDeltaT'
        QtMocHelpers::SlotData<double() const>(116, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getUseNutation'
        QtMocHelpers::SlotData<bool() const>(117, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseNutation'
        QtMocHelpers::SlotData<void(bool)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 119 },
        }}),
        // Slot 'getUseAberration'
        QtMocHelpers::SlotData<bool() const>(120, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseAberration'
        QtMocHelpers::SlotData<void(bool)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 119 },
        }}),
        // Slot 'getAberrationFactor'
        QtMocHelpers::SlotData<double() const>(122, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setAberrationFactor'
        QtMocHelpers::SlotData<void(double)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 124 },
        }}),
        // Slot 'getAberrationShader'
        QtMocHelpers::SlotData<QByteArray() const>(125, 2, QMC::AccessPublic, QMetaType::QByteArray),
        // Slot 'setAberrationUniforms'
        QtMocHelpers::SlotData<void(QOpenGLShaderProgram &) const>(126, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 127, 128 },
        }}),
        // Slot 'getUseParallax'
        QtMocHelpers::SlotData<bool() const>(129, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseParallax'
        QtMocHelpers::SlotData<void(bool)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 119 },
        }}),
        // Slot 'getParallaxFactor'
        QtMocHelpers::SlotData<double() const>(131, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setParallaxFactor'
        QtMocHelpers::SlotData<void(double)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 124 },
        }}),
        // Slot 'getUseTopocentricCoordinates'
        QtMocHelpers::SlotData<bool() const>(133, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setUseTopocentricCoordinates'
        QtMocHelpers::SlotData<void(bool)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 119 },
        }}),
        // Slot 'getPresetSkyTime'
        QtMocHelpers::SlotData<double() const>(135, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setPresetSkyTime'
        QtMocHelpers::SlotData<void(double)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 137 },
        }}),
        // Slot 'setTimeRate'
        QtMocHelpers::SlotData<void(double)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 139 },
        }}),
        // Slot 'getTimeRate'
        QtMocHelpers::SlotData<double() const>(140, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'toggleTimeSpeed'
        QtMocHelpers::SlotData<void()>(141, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'revertTimeDirection'
        QtMocHelpers::SlotData<void()>(142, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'increaseTimeSpeed'
        QtMocHelpers::SlotData<void()>(143, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'decreaseTimeSpeed'
        QtMocHelpers::SlotData<void()>(144, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'increaseTimeSpeedLess'
        QtMocHelpers::SlotData<void()>(145, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'decreaseTimeSpeedLess'
        QtMocHelpers::SlotData<void()>(146, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setZeroTimeSpeed'
        QtMocHelpers::SlotData<void()>(147, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setRealTimeSpeed'
        QtMocHelpers::SlotData<void()>(148, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'toggleRealTimeSpeed'
        QtMocHelpers::SlotData<void()>(149, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getRealTimeSpeed'
        QtMocHelpers::SlotData<bool() const>(150, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setTimeNow'
        QtMocHelpers::SlotData<void()>(151, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setTodayTime'
        QtMocHelpers::SlotData<void(const QTime &)>(152, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QTime, 46 },
        }}),
        // Slot 'getIsTimeNow'
        QtMocHelpers::SlotData<bool() const>(153, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getInitTodayTime'
        QtMocHelpers::SlotData<QTime() const>(154, 2, QMC::AccessPublic, QMetaType::QTime),
        // Slot 'setInitTodayTime'
        QtMocHelpers::SlotData<void(const QTime &)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QTime, 156 },
        }}),
        // Slot 'setPresetSkyTime'
        QtMocHelpers::SlotData<void(QDateTime)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QDateTime, 157 },
        }}),
        // Slot 'addMinute'
        QtMocHelpers::SlotData<void()>(158, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addHour'
        QtMocHelpers::SlotData<void()>(159, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addDay'
        QtMocHelpers::SlotData<void()>(160, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addWeek'
        QtMocHelpers::SlotData<void()>(161, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addSiderealDay'
        QtMocHelpers::SlotData<void()>(162, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addSiderealWeek'
        QtMocHelpers::SlotData<void()>(163, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addSiderealYear'
        QtMocHelpers::SlotData<void()>(164, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addSiderealYears'
        QtMocHelpers::SlotData<void(double)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'addSiderealYears'
        QtMocHelpers::SlotData<void()>(165, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'subtractMinute'
        QtMocHelpers::SlotData<void()>(167, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractHour'
        QtMocHelpers::SlotData<void()>(168, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractDay'
        QtMocHelpers::SlotData<void()>(169, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractWeek'
        QtMocHelpers::SlotData<void()>(170, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractSiderealDay'
        QtMocHelpers::SlotData<void()>(171, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractSiderealWeek'
        QtMocHelpers::SlotData<void()>(172, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractSiderealYear'
        QtMocHelpers::SlotData<void()>(173, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractSiderealYears'
        QtMocHelpers::SlotData<void(double)>(174, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'subtractSiderealYears'
        QtMocHelpers::SlotData<void()>(174, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'addSynodicMonth'
        QtMocHelpers::SlotData<void()>(175, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addMetonicCycle'
        QtMocHelpers::SlotData<void()>(176, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addSaros'
        QtMocHelpers::SlotData<void()>(177, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addDraconicYear'
        QtMocHelpers::SlotData<void()>(178, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addDraconicMonth'
        QtMocHelpers::SlotData<void()>(179, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addAnomalisticMonth'
        QtMocHelpers::SlotData<void()>(180, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addAnomalisticYear'
        QtMocHelpers::SlotData<void()>(181, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addAnomalisticYears'
        QtMocHelpers::SlotData<void(double)>(182, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'addAnomalisticYears'
        QtMocHelpers::SlotData<void()>(182, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'addMeanTropicalMonth'
        QtMocHelpers::SlotData<void()>(183, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addMeanTropicalYear'
        QtMocHelpers::SlotData<void()>(184, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addMeanTropicalYears'
        QtMocHelpers::SlotData<void(double)>(185, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'addMeanTropicalYears'
        QtMocHelpers::SlotData<void()>(185, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'addTropicalYear'
        QtMocHelpers::SlotData<void()>(186, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addGreatYear'
        QtMocHelpers::SlotData<void()>(187, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addCalendarMonth'
        QtMocHelpers::SlotData<void()>(188, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addCalendarYear'
        QtMocHelpers::SlotData<void()>(189, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addCalendarDecade'
        QtMocHelpers::SlotData<void()>(190, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addCalendarCentury'
        QtMocHelpers::SlotData<void()>(191, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addJulianYear'
        QtMocHelpers::SlotData<void()>(192, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addJulianYears'
        QtMocHelpers::SlotData<void(double)>(193, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'addJulianYears'
        QtMocHelpers::SlotData<void()>(193, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'addGaussianYear'
        QtMocHelpers::SlotData<void()>(194, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractSynodicMonth'
        QtMocHelpers::SlotData<void()>(195, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractMetonicCycle'
        QtMocHelpers::SlotData<void()>(196, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractSaros'
        QtMocHelpers::SlotData<void()>(197, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractDraconicYear'
        QtMocHelpers::SlotData<void()>(198, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractDraconicMonth'
        QtMocHelpers::SlotData<void()>(199, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractAnomalisticMonth'
        QtMocHelpers::SlotData<void()>(200, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractAnomalisticYear'
        QtMocHelpers::SlotData<void()>(201, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractAnomalisticYears'
        QtMocHelpers::SlotData<void(double)>(202, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'subtractAnomalisticYears'
        QtMocHelpers::SlotData<void()>(202, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'subtractMeanTropicalMonth'
        QtMocHelpers::SlotData<void()>(203, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractMeanTropicalYear'
        QtMocHelpers::SlotData<void()>(204, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractMeanTropicalYears'
        QtMocHelpers::SlotData<void(double)>(205, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'subtractMeanTropicalYears'
        QtMocHelpers::SlotData<void()>(205, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'subtractTropicalYear'
        QtMocHelpers::SlotData<void()>(206, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractGreatYear'
        QtMocHelpers::SlotData<void()>(207, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractCalendarMonth'
        QtMocHelpers::SlotData<void()>(208, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractCalendarYear'
        QtMocHelpers::SlotData<void()>(209, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractCalendarDecade'
        QtMocHelpers::SlotData<void()>(210, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractCalendarCentury'
        QtMocHelpers::SlotData<void()>(211, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractJulianYear'
        QtMocHelpers::SlotData<void()>(212, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'subtractJulianYears'
        QtMocHelpers::SlotData<void(double)>(213, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 166 },
        }}),
        // Slot 'subtractJulianYears'
        QtMocHelpers::SlotData<void()>(213, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'subtractGaussianYear'
        QtMocHelpers::SlotData<void()>(214, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addSolarDays'
        QtMocHelpers::SlotData<void(double)>(215, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 137 },
        }}),
        // Slot 'addSiderealDays'
        QtMocHelpers::SlotData<void(double)>(216, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 137 },
        }}),
        // Slot 'moveObserverToSelected'
        QtMocHelpers::SlotData<void()>(217, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setDeltaTCustomYear'
        QtMocHelpers::SlotData<void(double)>(218, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 219 },
        }}),
        // Slot 'setDeltaTCustomNDot'
        QtMocHelpers::SlotData<void(double)>(220, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 221 },
        }}),
        // Slot 'setDeltaTCustomEquationCoefficients'
        QtMocHelpers::SlotData<void(const Vec3d &)>(222, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 223, 224 },
        }}),
        // Slot 'getDeltaTCustomYear'
        QtMocHelpers::SlotData<double() const>(225, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getDeltaTCustomNDot'
        QtMocHelpers::SlotData<double() const>(226, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getDeltaTnDot'
        QtMocHelpers::SlotData<double() const>(227, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getDeltaTCustomEquationCoefficients'
        QtMocHelpers::SlotData<Vec3d() const>(228, 2, QMC::AccessPublic, 0x80000000 | 223),
        // Slot 'initEphemeridesFunctions'
        QtMocHelpers::SlotData<void()>(229, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'de430IsAvailable'
        QtMocHelpers::SlotData<bool()>(230, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'de431IsAvailable'
        QtMocHelpers::SlotData<bool()>(231, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'de430IsActive'
        QtMocHelpers::SlotData<bool()>(232, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'de431IsActive'
        QtMocHelpers::SlotData<bool()>(233, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setDe430Active'
        QtMocHelpers::SlotData<void(bool)>(234, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 235 },
        }}),
        // Slot 'setDe431Active'
        QtMocHelpers::SlotData<void(bool)>(236, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 235 },
        }}),
        // Slot 'de440IsAvailable'
        QtMocHelpers::SlotData<bool()>(237, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'de441IsAvailable'
        QtMocHelpers::SlotData<bool()>(238, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'de440IsActive'
        QtMocHelpers::SlotData<bool()>(239, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'de441IsActive'
        QtMocHelpers::SlotData<bool()>(240, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setDe440Active'
        QtMocHelpers::SlotData<void(bool)>(241, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 235 },
        }}),
        // Slot 'setDe441Active'
        QtMocHelpers::SlotData<void(bool)>(242, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 235 },
        }}),
        // Slot 'setMinMaxEphemRange'
        QtMocHelpers::SlotData<void(QPair<int,int>)>(243, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 244, 245 },
        }}),
        // Slot 'getMinMaxEphemRange'
        QtMocHelpers::SlotData<QPair<int,int>()>(246, 2, QMC::AccessPublic, 0x80000000 | 244),
        // Slot 'getIAUConstellation'
        QtMocHelpers::SlotData<QString(const Vec3d &) const>(247, 2, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 223, 248 },
        }}),
        // Slot 'luminanceToNELM'
        QtMocHelpers::SlotData<float(float)>(249, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Float, 250 },
        }}),
        // Slot 'nelmToLuminance'
        QtMocHelpers::SlotData<float(float)>(251, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Float, 252 },
        }}),
        // Slot 'bortleScaleIndexToNELM'
        QtMocHelpers::SlotData<float(int)>(253, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Int, 254 },
        }}),
        // Slot 'bortleScaleIndexToLuminance'
        QtMocHelpers::SlotData<float(const int)>(255, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Int, 254 },
        }}),
        // Slot 'nelmToBortleScaleIndex'
        QtMocHelpers::SlotData<int(float)>(256, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Float, 252 },
        }}),
        // Slot 'luminanceToBortleScaleIndex'
        QtMocHelpers::SlotData<int(const float)>(257, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Float, 250 },
        }}),
        // Slot 'luminanceToMPSAS'
        QtMocHelpers::SlotData<float(const float)>(258, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Float, 259 },
        }}),
        // Slot 'mpsasToLuminance'
        QtMocHelpers::SlotData<float(const float)>(260, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Float, 261 },
        }}),
        // Slot 'updateFixedEquatorialTransformMatrices'
        QtMocHelpers::SlotData<void()>(262, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'flipHorz'
        QtMocHelpers::PropertyData<bool>(263, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'flipVert'
        QtMocHelpers::PropertyData<bool>(264, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'flagUseNutation'
        QtMocHelpers::PropertyData<bool>(265, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 14),
        // property 'flagUseAberration'
        QtMocHelpers::PropertyData<bool>(266, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 15),
        // property 'aberrationFactor'
        QtMocHelpers::PropertyData<double>(267, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'flagUseParallax'
        QtMocHelpers::PropertyData<bool>(268, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 17),
        // property 'parallaxFactor'
        QtMocHelpers::PropertyData<double>(269, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'flagUseTopocentricCoordinates'
        QtMocHelpers::PropertyData<bool>(270, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 19),
        // property 'currentProjectionType'
        QtMocHelpers::PropertyData<enum ProjectionType>(271, 0x80000000 | 272, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 20),
        // property 'currentProjectionTypeKey'
        QtMocHelpers::PropertyData<QString>(273, QMetaType::QString, QMC::Readable | QMC::Writable | QMC::Designable | QMC::Scriptable | QMC::StdCppSet, 21),
        // property 'currentProjectionNameI18n'
        QtMocHelpers::PropertyData<QString>(274, QMetaType::QString, QMC::Readable | QMC::Designable | QMC::Scriptable, 22),
        // property 'flagGravityLabels'
        QtMocHelpers::PropertyData<bool>(275, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'currentTimeZone'
        QtMocHelpers::PropertyData<QString>(276, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'flagUseCTZ'
        QtMocHelpers::PropertyData<bool>(277, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 3),
        // property 'flagUseDST'
        QtMocHelpers::PropertyData<bool>(278, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 4),
        // property 'startupTimeStop'
        QtMocHelpers::PropertyData<bool>(279, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'ditheringMode'
        QtMocHelpers::PropertyData<DitheringMode>(280, 0x80000000 | 42, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 26),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'FrameType'
        QtMocHelpers::EnumData<enum FrameType>(281, 281, QMC::EnumFlags{}).add({
            {  282, FrameType::FrameUninitialized },
            {  283, FrameType::FrameAltAz },
            {  284, FrameType::FrameHeliocentricEclipticJ2000 },
            {  285, FrameType::FrameObservercentricEclipticJ2000 },
            {  286, FrameType::FrameObservercentricEclipticOfDate },
            {  287, FrameType::FrameEquinoxEqu },
            {  288, FrameType::FrameJ2000 },
            {  289, FrameType::FrameFixedEquatorial },
            {  290, FrameType::FrameGalactic },
            {  291, FrameType::FrameSupergalactic },
        }),
        // enum 'ProjectionType'
        QtMocHelpers::EnumData<enum ProjectionType>(272, 272, QMC::EnumFlags{}).add({
            {  292, ProjectionType::ProjectionPerspective },
            {  293, ProjectionType::ProjectionStereographic },
            {  294, ProjectionType::ProjectionFisheye },
            {  295, ProjectionType::ProjectionOrthographic },
            {  296, ProjectionType::ProjectionEqualArea },
            {  297, ProjectionType::ProjectionHammer },
            {  298, ProjectionType::ProjectionMollweide },
            {  299, ProjectionType::ProjectionSinusoidal },
            {  300, ProjectionType::ProjectionMercator },
            {  301, ProjectionType::ProjectionMiller },
            {  302, ProjectionType::ProjectionCylinder },
            {  303, ProjectionType::ProjectionCylinderFill },
        }),
        // enum 'RefractionMode'
        QtMocHelpers::EnumData<enum RefractionMode>(304, 304, QMC::EnumFlags{}).add({
            {  305, RefractionMode::RefractionAuto },
            {  306, RefractionMode::RefractionOn },
            {  307, RefractionMode::RefractionOff },
        }),
        // enum 'DeltaTAlgorithm'
        QtMocHelpers::EnumData<enum DeltaTAlgorithm>(308, 308, QMC::EnumFlags{}).add({
            {  309, DeltaTAlgorithm::WithoutCorrection },
            {  310, DeltaTAlgorithm::Schoch },
            {  311, DeltaTAlgorithm::Clemence },
            {  312, DeltaTAlgorithm::IAU },
            {  313, DeltaTAlgorithm::AstronomicalEphemeris },
            {  314, DeltaTAlgorithm::TuckermanGoldstine },
            {  315, DeltaTAlgorithm::MullerStephenson },
            {  316, DeltaTAlgorithm::Stephenson1978 },
            {  317, DeltaTAlgorithm::SchmadelZech1979 },
            {  318, DeltaTAlgorithm::MorrisonStephenson1982 },
            {  319, DeltaTAlgorithm::StephensonMorrison1984 },
            {  320, DeltaTAlgorithm::StephensonHoulden },
            {  321, DeltaTAlgorithm::Espenak },
            {  322, DeltaTAlgorithm::Borkowski },
            {  323, DeltaTAlgorithm::SchmadelZech1988 },
            {  324, DeltaTAlgorithm::ChaprontTouze },
            {  325, DeltaTAlgorithm::StephensonMorrison1995 },
            {  326, DeltaTAlgorithm::Stephenson1997 },
            {  327, DeltaTAlgorithm::ChaprontMeeus },
            {  328, DeltaTAlgorithm::JPLHorizons },
            {  329, DeltaTAlgorithm::MeeusSimons },
            {  330, DeltaTAlgorithm::MontenbruckPfleger },
            {  331, DeltaTAlgorithm::ReingoldDershowitz },
            {  332, DeltaTAlgorithm::MorrisonStephenson2004 },
            {  333, DeltaTAlgorithm::Reijs },
            {  334, DeltaTAlgorithm::EspenakMeeus },
            {  335, DeltaTAlgorithm::EspenakMeeusModified },
            {  336, DeltaTAlgorithm::EspenakMeeusZeroMoonAccel },
            {  337, DeltaTAlgorithm::Banjevic },
            {  338, DeltaTAlgorithm::IslamSadiqQureshi },
            {  339, DeltaTAlgorithm::KhalidSultanaZaidi },
            {  340, DeltaTAlgorithm::StephensonMorrisonHohenkerk2016 },
            {  341, DeltaTAlgorithm::Henriksson2017 },
            {  342, DeltaTAlgorithm::Custom },
        }),
    };
    return QtMocHelpers::metaObjectData<StelCore, qt_meta_tag_ZN8StelCoreE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject StelCore::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8StelCoreE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8StelCoreE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8StelCoreE_t>.metaTypes,
    nullptr
} };

void StelCore::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<StelCore *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->locationChanged((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1]))); break;
        case 1: _t->targetLocationChanged((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 2: _t->currentTimeZoneChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->useCustomTimeZoneChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->flagUseDSTChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->startupTimeStopChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->timeRateChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 7: _t->timeSyncOccurred((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 8: _t->dateChanged(); break;
        case 9: _t->dateChangedForTrails(); break;
        case 10: _t->dateChangedForMonth(); break;
        case 11: _t->dateChangedByYear((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->flipHorzChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->flipVertChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->flagUseNutationChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->flagUseAberrationChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->aberrationFactorChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 17: _t->flagUseParallaxChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->parallaxFactorChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 19: _t->flagUseTopocentricCoordinatesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->currentProjectionTypeChanged((*reinterpret_cast<std::add_pointer_t<StelCore::ProjectionType>>(_a[1]))); break;
        case 21: _t->currentProjectionTypeKeyChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 22: _t->currentProjectionNameI18nChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->flagGravityLabelsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->configurationDataSaved(); break;
        case 25: _t->updateSearchLists(); break;
        case 26: _t->ditheringModeChanged((*reinterpret_cast<std::add_pointer_t<DitheringMode>>(_a[1]))); break;
        case 27: _t->ephemAlgorithmChanged(); break;
        case 28: _t->moveObserverTo((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 29: _t->moveObserverTo((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[3]))); break;
        case 30: _t->moveObserverTo((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 31: _t->moveObserverTo((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1]))); break;
        case 32: _t->setCurrentProjectionType((*reinterpret_cast<std::add_pointer_t<StelCore::ProjectionType>>(_a[1]))); break;
        case 33: { StelCore::ProjectionType _r = _t->getCurrentProjectionType();
            if (_a[0]) *reinterpret_cast<StelCore::ProjectionType*>(_a[0]) = std::move(_r); }  break;
        case 34: { QString _r = _t->getCurrentProjectionTypeKey();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 35: _t->setCurrentProjectionTypeKey((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 36: { QString _r = _t->getCurrentProjectionNameI18n();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 37: { QStringList _r = _t->getAllProjectionTypeKeys();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 38: _t->setCurrentDeltaTAlgorithm((*reinterpret_cast<std::add_pointer_t<StelCore::DeltaTAlgorithm>>(_a[1]))); break;
        case 39: { StelCore::DeltaTAlgorithm _r = _t->getCurrentDeltaTAlgorithm();
            if (_a[0]) *reinterpret_cast<StelCore::DeltaTAlgorithm*>(_a[0]) = std::move(_r); }  break;
        case 40: { QString _r = _t->getCurrentDeltaTAlgorithmDescription();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 41: { QString _r = _t->getCurrentDeltaTAlgorithmKey();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 42: _t->setCurrentDeltaTAlgorithmKey((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 43: _t->setMaskType((*reinterpret_cast<std::add_pointer_t<StelProjector::StelProjectorMaskType>>(_a[1]))); break;
        case 44: _t->setFlagGravityLabels((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: { bool _r = _t->getFlagGravityLabels();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: _t->setDefaultAngleForGravityText((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 47: _t->setFlipHorz((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: _t->setFlipVert((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 49: { bool _r = _t->getFlipHorz();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 50: { bool _r = _t->getFlipVert();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 51: { double _r = _t->getViewportHorizontalOffset();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 52: _t->setViewportHorizontalOffset((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 53: { double _r = _t->getViewportVerticalOffset();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 54: _t->setViewportVerticalOffset((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 55: _t->setViewportOffset((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
        case 56: _t->setViewportStretch((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 57: { QString _r = _t->getDefaultLocationID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 58: _t->setDefaultLocationID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 59: _t->returnToDefaultLocation(); break;
        case 60: _t->returnToHome(); break;
        case 61: { double _r = _t->getJDOfLastJDUpdate();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 62: _t->setMilliSecondsOfLastJDUpdate((*reinterpret_cast<std::add_pointer_t<qint64>>(_a[1]))); break;
        case 63: { qint64 _r = _t->getMilliSecondsOfLastJDUpdate();
            if (_a[0]) *reinterpret_cast<qint64*>(_a[0]) = std::move(_r); }  break;
        case 64: _t->setJD((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 65: _t->setJDE((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 66: { double _r = _t->getJD();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 67: { double _r = _t->getJDE();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 68: { double _r = _t->getSolutionEquationOfTime((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 69: { double _r = _t->getSolutionEquationOfTime();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 70: { bool _r = _t->getUseDST();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 71: _t->setUseDST((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 72: { bool _r = _t->getStartupTimeStop();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 73: _t->setStartupTimeStop((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 74: { DitheringMode _r = _t->getDitheringMode();
            if (_a[0]) *reinterpret_cast<DitheringMode*>(_a[0]) = std::move(_r); }  break;
        case 75: _t->setDitheringMode((*reinterpret_cast<std::add_pointer_t<DitheringMode>>(_a[1]))); break;
        case 76: _t->setDitheringMode((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 77: { bool _r = _t->getUseCustomTimeZone();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 78: _t->setUseCustomTimeZone((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 79: _t->setMJDay((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 80: { double _r = _t->getMJDay();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 81: { double _r = _t->computeDeltaT((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 82: { double _r = _t->getDeltaT();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 83: { bool _r = _t->getUseNutation();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 84: _t->setUseNutation((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 85: { bool _r = _t->getUseAberration();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 86: _t->setUseAberration((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 87: { double _r = _t->getAberrationFactor();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 88: _t->setAberrationFactor((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 89: { QByteArray _r = _t->getAberrationShader();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 90: _t->setAberrationUniforms((*reinterpret_cast<std::add_pointer_t<QOpenGLShaderProgram&>>(_a[1]))); break;
        case 91: { bool _r = _t->getUseParallax();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 92: _t->setUseParallax((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 93: { double _r = _t->getParallaxFactor();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 94: _t->setParallaxFactor((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 95: { bool _r = _t->getUseTopocentricCoordinates();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 96: _t->setUseTopocentricCoordinates((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 97: { double _r = _t->getPresetSkyTime();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 98: _t->setPresetSkyTime((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 99: _t->setTimeRate((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 100: { double _r = _t->getTimeRate();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 101: _t->toggleTimeSpeed(); break;
        case 102: _t->revertTimeDirection(); break;
        case 103: _t->increaseTimeSpeed(); break;
        case 104: _t->decreaseTimeSpeed(); break;
        case 105: _t->increaseTimeSpeedLess(); break;
        case 106: _t->decreaseTimeSpeedLess(); break;
        case 107: _t->setZeroTimeSpeed(); break;
        case 108: _t->setRealTimeSpeed(); break;
        case 109: _t->toggleRealTimeSpeed(); break;
        case 110: { bool _r = _t->getRealTimeSpeed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 111: _t->setTimeNow(); break;
        case 112: _t->setTodayTime((*reinterpret_cast<std::add_pointer_t<QTime>>(_a[1]))); break;
        case 113: { bool _r = _t->getIsTimeNow();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 114: { QTime _r = _t->getInitTodayTime();
            if (_a[0]) *reinterpret_cast<QTime*>(_a[0]) = std::move(_r); }  break;
        case 115: _t->setInitTodayTime((*reinterpret_cast<std::add_pointer_t<QTime>>(_a[1]))); break;
        case 116: _t->setPresetSkyTime((*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[1]))); break;
        case 117: _t->addMinute(); break;
        case 118: _t->addHour(); break;
        case 119: _t->addDay(); break;
        case 120: _t->addWeek(); break;
        case 121: _t->addSiderealDay(); break;
        case 122: _t->addSiderealWeek(); break;
        case 123: _t->addSiderealYear(); break;
        case 124: _t->addSiderealYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 125: _t->addSiderealYears(); break;
        case 126: _t->subtractMinute(); break;
        case 127: _t->subtractHour(); break;
        case 128: _t->subtractDay(); break;
        case 129: _t->subtractWeek(); break;
        case 130: _t->subtractSiderealDay(); break;
        case 131: _t->subtractSiderealWeek(); break;
        case 132: _t->subtractSiderealYear(); break;
        case 133: _t->subtractSiderealYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 134: _t->subtractSiderealYears(); break;
        case 135: _t->addSynodicMonth(); break;
        case 136: _t->addMetonicCycle(); break;
        case 137: _t->addSaros(); break;
        case 138: _t->addDraconicYear(); break;
        case 139: _t->addDraconicMonth(); break;
        case 140: _t->addAnomalisticMonth(); break;
        case 141: _t->addAnomalisticYear(); break;
        case 142: _t->addAnomalisticYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 143: _t->addAnomalisticYears(); break;
        case 144: _t->addMeanTropicalMonth(); break;
        case 145: _t->addMeanTropicalYear(); break;
        case 146: _t->addMeanTropicalYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 147: _t->addMeanTropicalYears(); break;
        case 148: _t->addTropicalYear(); break;
        case 149: _t->addGreatYear(); break;
        case 150: _t->addCalendarMonth(); break;
        case 151: _t->addCalendarYear(); break;
        case 152: _t->addCalendarDecade(); break;
        case 153: _t->addCalendarCentury(); break;
        case 154: _t->addJulianYear(); break;
        case 155: _t->addJulianYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 156: _t->addJulianYears(); break;
        case 157: _t->addGaussianYear(); break;
        case 158: _t->subtractSynodicMonth(); break;
        case 159: _t->subtractMetonicCycle(); break;
        case 160: _t->subtractSaros(); break;
        case 161: _t->subtractDraconicYear(); break;
        case 162: _t->subtractDraconicMonth(); break;
        case 163: _t->subtractAnomalisticMonth(); break;
        case 164: _t->subtractAnomalisticYear(); break;
        case 165: _t->subtractAnomalisticYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 166: _t->subtractAnomalisticYears(); break;
        case 167: _t->subtractMeanTropicalMonth(); break;
        case 168: _t->subtractMeanTropicalYear(); break;
        case 169: _t->subtractMeanTropicalYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 170: _t->subtractMeanTropicalYears(); break;
        case 171: _t->subtractTropicalYear(); break;
        case 172: _t->subtractGreatYear(); break;
        case 173: _t->subtractCalendarMonth(); break;
        case 174: _t->subtractCalendarYear(); break;
        case 175: _t->subtractCalendarDecade(); break;
        case 176: _t->subtractCalendarCentury(); break;
        case 177: _t->subtractJulianYear(); break;
        case 178: _t->subtractJulianYears((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 179: _t->subtractJulianYears(); break;
        case 180: _t->subtractGaussianYear(); break;
        case 181: _t->addSolarDays((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 182: _t->addSiderealDays((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 183: _t->moveObserverToSelected(); break;
        case 184: _t->setDeltaTCustomYear((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 185: _t->setDeltaTCustomNDot((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 186: _t->setDeltaTCustomEquationCoefficients((*reinterpret_cast<std::add_pointer_t<Vec3d>>(_a[1]))); break;
        case 187: { double _r = _t->getDeltaTCustomYear();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 188: { double _r = _t->getDeltaTCustomNDot();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 189: { double _r = _t->getDeltaTnDot();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 190: { Vec3d _r = _t->getDeltaTCustomEquationCoefficients();
            if (_a[0]) *reinterpret_cast<Vec3d*>(_a[0]) = std::move(_r); }  break;
        case 191: _t->initEphemeridesFunctions(); break;
        case 192: { bool _r = _t->de430IsAvailable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 193: { bool _r = _t->de431IsAvailable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 194: { bool _r = _t->de430IsActive();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 195: { bool _r = _t->de431IsActive();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 196: _t->setDe430Active((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 197: _t->setDe431Active((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 198: { bool _r = _t->de440IsAvailable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 199: { bool _r = _t->de441IsAvailable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 200: { bool _r = _t->de440IsActive();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 201: { bool _r = _t->de441IsActive();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 202: _t->setDe440Active((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 203: _t->setDe441Active((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 204: _t->setMinMaxEphemRange((*reinterpret_cast<std::add_pointer_t<std::pair<int,int>>>(_a[1]))); break;
        case 205: { std::pair<int,int> _r = _t->getMinMaxEphemRange();
            if (_a[0]) *reinterpret_cast<std::pair<int,int>*>(_a[0]) = std::move(_r); }  break;
        case 206: { QString _r = _t->getIAUConstellation((*reinterpret_cast<std::add_pointer_t<Vec3d>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 207: { float _r = _t->luminanceToNELM((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 208: { float _r = _t->nelmToLuminance((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 209: { float _r = _t->bortleScaleIndexToNELM((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 210: { float _r = _t->bortleScaleIndexToLuminance((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 211: { int _r = _t->nelmToBortleScaleIndex((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 212: { int _r = _t->luminanceToBortleScaleIndex((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 213: { float _r = _t->luminanceToMPSAS((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 214: { float _r = _t->mpsasToLuminance((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 215: _t->updateFixedEquatorialTransformMatrices(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 26:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< DitheringMode >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 29:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 30:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        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< DitheringMode >(); break;
            }
            break;
        case 186:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3d >(); break;
            }
            break;
        case 206:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3d >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const StelLocation & )>(_a, &StelCore::locationChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const StelLocation & , const QString & )>(_a, &StelCore::targetLocationChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const QString & )>(_a, &StelCore::currentTimeZoneChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const bool )>(_a, &StelCore::useCustomTimeZoneChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const bool )>(_a, &StelCore::flagUseDSTChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const bool )>(_a, &StelCore::startupTimeStopChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(double )>(_a, &StelCore::timeRateChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(double )>(_a, &StelCore::timeSyncOccurred, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)()>(_a, &StelCore::dateChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)()>(_a, &StelCore::dateChangedForTrails, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)()>(_a, &StelCore::dateChangedForMonth, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const int )>(_a, &StelCore::dateChangedByYear, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flipHorzChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flipVertChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flagUseNutationChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flagUseAberrationChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(double )>(_a, &StelCore::aberrationFactorChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flagUseParallaxChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(double )>(_a, &StelCore::parallaxFactorChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flagUseTopocentricCoordinatesChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(StelCore::ProjectionType )>(_a, &StelCore::currentProjectionTypeChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const QString & )>(_a, &StelCore::currentProjectionTypeKeyChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(const QString & )>(_a, &StelCore::currentProjectionNameI18nChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(bool )>(_a, &StelCore::flagGravityLabelsChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)()>(_a, &StelCore::configurationDataSaved, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)()>(_a, &StelCore::updateSearchLists, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)(DitheringMode )>(_a, &StelCore::ditheringModeChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelCore::*)()>(_a, &StelCore::ephemAlgorithmChanged, 27))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 16:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< DitheringMode >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->getFlipHorz(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlipVert(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->getUseNutation(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->getUseAberration(); break;
        case 4: *reinterpret_cast<double*>(_v) = _t->getAberrationFactor(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->getUseParallax(); break;
        case 6: *reinterpret_cast<double*>(_v) = _t->getParallaxFactor(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getUseTopocentricCoordinates(); break;
        case 8: *reinterpret_cast<enum ProjectionType*>(_v) = _t->getCurrentProjectionType(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->getCurrentProjectionTypeKey(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->getCurrentProjectionNameI18n(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->getFlagGravityLabels(); break;
        case 12: *reinterpret_cast<QString*>(_v) = _t->getCurrentTimeZone(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getUseCustomTimeZone(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->getUseDST(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->getStartupTimeStop(); break;
        case 16: *reinterpret_cast<DitheringMode*>(_v) = _t->getDitheringMode(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlipHorz(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlipVert(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setUseNutation(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->setUseAberration(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setAberrationFactor(*reinterpret_cast<double*>(_v)); break;
        case 5: _t->setUseParallax(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setParallaxFactor(*reinterpret_cast<double*>(_v)); break;
        case 7: _t->setUseTopocentricCoordinates(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setCurrentProjectionType(*reinterpret_cast<enum ProjectionType*>(_v)); break;
        case 9: _t->setCurrentProjectionTypeKey(*reinterpret_cast<QString*>(_v)); break;
        case 11: _t->setFlagGravityLabels(*reinterpret_cast<bool*>(_v)); break;
        case 12: _t->setCurrentTimeZone(*reinterpret_cast<QString*>(_v)); break;
        case 13: _t->setUseCustomTimeZone(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setUseDST(*reinterpret_cast<bool*>(_v)); break;
        case 15: _t->setStartupTimeStop(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setDitheringMode(*reinterpret_cast<DitheringMode*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void StelCore::locationChanged(const StelLocation & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void StelCore::targetLocationChanged(const StelLocation & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

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

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

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

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

// SIGNAL 6
void StelCore::timeRateChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void StelCore::timeSyncOccurred(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void StelCore::dateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void StelCore::dateChangedForTrails()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void StelCore::dateChangedForMonth()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void StelCore::dateChangedByYear(const int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

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

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

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

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

// SIGNAL 16
void StelCore::aberrationFactorChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

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

// SIGNAL 18
void StelCore::parallaxFactorChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

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

// SIGNAL 20
void StelCore::currentProjectionTypeChanged(StelCore::ProjectionType _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void StelCore::currentProjectionTypeKeyChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void StelCore::currentProjectionNameI18nChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

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

// SIGNAL 24
void StelCore::configurationDataSaved()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void StelCore::updateSearchLists()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void StelCore::ditheringModeChanged(DitheringMode _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void StelCore::ephemAlgorithmChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}
QT_WARNING_POP
