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

template <> constexpr inline auto GridLinesMgr::qt_create_metaobjectdata<qt_meta_tag_ZN12GridLinesMgrE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "GridLinesMgr",
        "gridlinesDisplayedChanged",
        "",
        "lineThicknessChanged",
        "partThicknessChanged",
        "pointSizeChanged",
        "azimuthalGridDisplayedChanged",
        "azimuthalGridColorChanged",
        "Vec3f",
        "newColor",
        "equatorGridDisplayedChanged",
        "displayed",
        "equatorGridColorChanged",
        "fixedEquatorGridDisplayedChanged",
        "fixedEquatorGridColorChanged",
        "equatorJ2000GridDisplayedChanged",
        "equatorJ2000GridColorChanged",
        "eclipticGridDisplayedChanged",
        "eclipticGridColorChanged",
        "eclipticJ2000GridDisplayedChanged",
        "eclipticJ2000GridColorChanged",
        "galacticGridDisplayedChanged",
        "galacticGridColorChanged",
        "supergalacticGridDisplayedChanged",
        "supergalacticGridColorChanged",
        "equatorLineDisplayedChanged",
        "equatorPartsDisplayedChanged",
        "equatorPartsLabeledChanged",
        "equatorLineColorChanged",
        "equatorJ2000LineDisplayedChanged",
        "equatorJ2000PartsDisplayedChanged",
        "equatorJ2000PartsLabeledChanged",
        "equatorJ2000LineColorChanged",
        "fixedEquatorLineDisplayedChanged",
        "fixedEquatorPartsDisplayedChanged",
        "fixedEquatorPartsLabeledChanged",
        "fixedEquatorLineColorChanged",
        "eclipticLineDisplayedChanged",
        "eclipticPartsDisplayedChanged",
        "eclipticPartsLabeledChanged",
        "eclipticDatesLabeledChanged",
        "eclipticLineColorChanged",
        "invariablePlaneLineDisplayedChanged",
        "invariablePlaneLineColorChanged",
        "solarEquatorLineDisplayedChanged",
        "solarEquatorPartsDisplayedChanged",
        "solarEquatorPartsLabeledChanged",
        "solarEquatorLineColorChanged",
        "eclipticJ2000LineDisplayedChanged",
        "eclipticJ2000PartsDisplayedChanged",
        "eclipticJ2000PartsLabeledChanged",
        "eclipticJ2000LineColorChanged",
        "precessionCirclesDisplayedChanged",
        "precessionPartsDisplayedChanged",
        "precessionPartsLabeledChanged",
        "precessionCirclesColorChanged",
        "meridianLineDisplayedChanged",
        "meridianPartsDisplayedChanged",
        "meridianPartsLabeledChanged",
        "meridianLineColorChanged",
        "longitudeLineDisplayedChanged",
        "longitudePartsDisplayedChanged",
        "longitudePartsLabeledChanged",
        "longitudeLineColorChanged",
        "quadratureLineDisplayedChanged",
        "quadratureLineColorChanged",
        "horizonLineDisplayedChanged",
        "horizonPartsDisplayedChanged",
        "horizonPartsLabeledChanged",
        "horizonLineColorChanged",
        "galacticEquatorLineDisplayedChanged",
        "galacticEquatorPartsDisplayedChanged",
        "galacticEquatorPartsLabeledChanged",
        "galacticEquatorLineColorChanged",
        "supergalacticEquatorLineDisplayedChanged",
        "supergalacticEquatorPartsDisplayedChanged",
        "supergalacticEquatorPartsLabeledChanged",
        "supergalacticEquatorLineColorChanged",
        "primeVerticalLineDisplayedChanged",
        "primeVerticalPartsDisplayedChanged",
        "primeVerticalPartsLabeledChanged",
        "primeVerticalLineColorChanged",
        "currentVerticalLineDisplayedChanged",
        "currentVerticalPartsDisplayedChanged",
        "currentVerticalPartsLabeledChanged",
        "currentVerticalLineColorChanged",
        "colureLinesDisplayedChanged",
        "colurePartsDisplayedChanged",
        "colurePartsLabeledChanged",
        "colureLinesColorChanged",
        "circumpolarCirclesDisplayedChanged",
        "circumpolarCirclesColorChanged",
        "umbraCircleDisplayedChanged",
        "umbraCircleColorChanged",
        "penumbraCircleDisplayedChanged",
        "penumbraCircleColorChanged",
        "celestialJ2000PolesDisplayedChanged",
        "celestialJ2000PolesColorChanged",
        "celestialPolesDisplayedChanged",
        "celestialPolesColorChanged",
        "zenithNadirDisplayedChanged",
        "zenithNadirColorChanged",
        "eclipticJ2000PolesDisplayedChanged",
        "eclipticJ2000PolesColorChanged",
        "eclipticPolesDisplayedChanged",
        "eclipticPolesColorChanged",
        "galacticPolesDisplayedChanged",
        "galacticPolesColorChanged",
        "galacticCenterDisplayedChanged",
        "galacticCenterColorChanged",
        "supergalacticPolesDisplayedChanged",
        "supergalacticPolesColorChanged",
        "equinoxJ2000PointsDisplayedChanged",
        "equinoxJ2000PointsColorChanged",
        "equinoxPointsDisplayedChanged",
        "equinoxPointsColorChanged",
        "solsticeJ2000PointsDisplayedChanged",
        "solsticeJ2000PointsColorChanged",
        "solsticePointsDisplayedChanged",
        "solsticePointsColorChanged",
        "antisolarPointDisplayedChanged",
        "antisolarPointColorChanged",
        "umbraCenterPointDisplayedChanged",
        "apexPointsDisplayedChanged",
        "apexPointsColorChanged",
        "gridSpacingMultiplierChanged",
        "multiplier",
        "setFlagGridlines",
        "getFlagGridlines",
        "setFlagAllGrids",
        "setFlagAllLines",
        "setFlagAllPoints",
        "setFlagAzimuthalGrid",
        "getFlagAzimuthalGrid",
        "getColorAzimuthalGrid",
        "setColorAzimuthalGrid",
        "setFlagEquatorGrid",
        "getFlagEquatorGrid",
        "getColorEquatorGrid",
        "setColorEquatorGrid",
        "setFlagFixedEquatorGrid",
        "getFlagFixedEquatorGrid",
        "getColorFixedEquatorGrid",
        "setColorFixedEquatorGrid",
        "setFlagEquatorJ2000Grid",
        "getFlagEquatorJ2000Grid",
        "getColorEquatorJ2000Grid",
        "setColorEquatorJ2000Grid",
        "setFlagEclipticJ2000Grid",
        "getFlagEclipticJ2000Grid",
        "getColorEclipticJ2000Grid",
        "setColorEclipticJ2000Grid",
        "setFlagEclipticGrid",
        "getFlagEclipticGrid",
        "getColorEclipticGrid",
        "setColorEclipticGrid",
        "setFlagGalacticGrid",
        "getFlagGalacticGrid",
        "getColorGalacticGrid",
        "setColorGalacticGrid",
        "setFlagSupergalacticGrid",
        "getFlagSupergalacticGrid",
        "getColorSupergalacticGrid",
        "setColorSupergalacticGrid",
        "setFlagEquatorLine",
        "getFlagEquatorLine",
        "setFlagEquatorParts",
        "getFlagEquatorParts",
        "setFlagEquatorLabeled",
        "getFlagEquatorLabeled",
        "getColorEquatorLine",
        "setColorEquatorLine",
        "setFlagEquatorJ2000Line",
        "getFlagEquatorJ2000Line",
        "setFlagEquatorJ2000Parts",
        "getFlagEquatorJ2000Parts",
        "setFlagEquatorJ2000Labeled",
        "getFlagEquatorJ2000Labeled",
        "getColorEquatorJ2000Line",
        "setColorEquatorJ2000Line",
        "setFlagFixedEquatorLine",
        "getFlagFixedEquatorLine",
        "setFlagFixedEquatorParts",
        "getFlagFixedEquatorParts",
        "setFlagFixedEquatorLabeled",
        "getFlagFixedEquatorLabeled",
        "getColorFixedEquatorLine",
        "setColorFixedEquatorLine",
        "setFlagEclipticJ2000Line",
        "getFlagEclipticJ2000Line",
        "setFlagEclipticJ2000Parts",
        "getFlagEclipticJ2000Parts",
        "setFlagEclipticJ2000Labeled",
        "getFlagEclipticJ2000Labeled",
        "getColorEclipticJ2000Line",
        "setColorEclipticJ2000Line",
        "setFlagEclipticLine",
        "getFlagEclipticLine",
        "setFlagEclipticParts",
        "getFlagEclipticParts",
        "setFlagEclipticLabeled",
        "getFlagEclipticLabeled",
        "setFlagEclipticDatesLabeled",
        "getFlagEclipticDatesLabeled",
        "getColorEclipticLine",
        "setColorEclipticLine",
        "setFlagInvariablePlaneLine",
        "getFlagInvariablePlaneLine",
        "getColorInvariablePlaneLine",
        "setColorInvariablePlaneLine",
        "setFlagSolarEquatorLine",
        "getFlagSolarEquatorLine",
        "setFlagSolarEquatorParts",
        "getFlagSolarEquatorParts",
        "setFlagSolarEquatorLabeled",
        "getFlagSolarEquatorLabeled",
        "getColorSolarEquatorLine",
        "setColorSolarEquatorLine",
        "setFlagPrecessionCircles",
        "getFlagPrecessionCircles",
        "setFlagPrecessionParts",
        "getFlagPrecessionParts",
        "setFlagPrecessionLabeled",
        "getFlagPrecessionLabeled",
        "getColorPrecessionCircles",
        "setColorPrecessionCircles",
        "setFlagMeridianLine",
        "getFlagMeridianLine",
        "setFlagMeridianParts",
        "getFlagMeridianParts",
        "setFlagMeridianLabeled",
        "getFlagMeridianLabeled",
        "getColorMeridianLine",
        "setColorMeridianLine",
        "setFlagLongitudeLine",
        "getFlagLongitudeLine",
        "setFlagLongitudeParts",
        "getFlagLongitudeParts",
        "setFlagLongitudeLabeled",
        "getFlagLongitudeLabeled",
        "getColorLongitudeLine",
        "setColorLongitudeLine",
        "setFlagQuadratureLine",
        "getFlagQuadratureLine",
        "getColorQuadratureLine",
        "setColorQuadratureLine",
        "setFlagHorizonLine",
        "getFlagHorizonLine",
        "setFlagHorizonParts",
        "getFlagHorizonParts",
        "setFlagHorizonLabeled",
        "getFlagHorizonLabeled",
        "getColorHorizonLine",
        "setColorHorizonLine",
        "setFlagGalacticEquatorLine",
        "getFlagGalacticEquatorLine",
        "setFlagGalacticEquatorParts",
        "getFlagGalacticEquatorParts",
        "setFlagGalacticEquatorLabeled",
        "getFlagGalacticEquatorLabeled",
        "getColorGalacticEquatorLine",
        "setColorGalacticEquatorLine",
        "setFlagSupergalacticEquatorLine",
        "getFlagSupergalacticEquatorLine",
        "setFlagSupergalacticEquatorParts",
        "getFlagSupergalacticEquatorParts",
        "setFlagSupergalacticEquatorLabeled",
        "getFlagSupergalacticEquatorLabeled",
        "getColorSupergalacticEquatorLine",
        "setColorSupergalacticEquatorLine",
        "setFlagPrimeVerticalLine",
        "getFlagPrimeVerticalLine",
        "setFlagPrimeVerticalParts",
        "getFlagPrimeVerticalParts",
        "setFlagPrimeVerticalLabeled",
        "getFlagPrimeVerticalLabeled",
        "getColorPrimeVerticalLine",
        "setColorPrimeVerticalLine",
        "setFlagCurrentVerticalLine",
        "getFlagCurrentVerticalLine",
        "setFlagCurrentVerticalParts",
        "getFlagCurrentVerticalParts",
        "setFlagCurrentVerticalLabeled",
        "getFlagCurrentVerticalLabeled",
        "getColorCurrentVerticalLine",
        "setColorCurrentVerticalLine",
        "setFlagColureLines",
        "getFlagColureLines",
        "setFlagColureParts",
        "getFlagColureParts",
        "setFlagColureLabeled",
        "getFlagColureLabeled",
        "getColorColureLines",
        "setColorColureLines",
        "setFlagCircumpolarCircles",
        "getFlagCircumpolarCircles",
        "getColorCircumpolarCircles",
        "setColorCircumpolarCircles",
        "setFlagUmbraCircle",
        "getFlagUmbraCircle",
        "getColorUmbraCircle",
        "setColorUmbraCircle",
        "setFlagPenumbraCircle",
        "getFlagPenumbraCircle",
        "getColorPenumbraCircle",
        "setColorPenumbraCircle",
        "setFlagCelestialJ2000Poles",
        "getFlagCelestialJ2000Poles",
        "getColorCelestialJ2000Poles",
        "setColorCelestialJ2000Poles",
        "setFlagCelestialPoles",
        "getFlagCelestialPoles",
        "getColorCelestialPoles",
        "setColorCelestialPoles",
        "setFlagZenithNadir",
        "getFlagZenithNadir",
        "getColorZenithNadir",
        "setColorZenithNadir",
        "setFlagEclipticJ2000Poles",
        "getFlagEclipticJ2000Poles",
        "getColorEclipticJ2000Poles",
        "setColorEclipticJ2000Poles",
        "setFlagEclipticPoles",
        "getFlagEclipticPoles",
        "getColorEclipticPoles",
        "setColorEclipticPoles",
        "setFlagGalacticPoles",
        "getFlagGalacticPoles",
        "getColorGalacticPoles",
        "setColorGalacticPoles",
        "setFlagGalacticCenter",
        "getFlagGalacticCenter",
        "getColorGalacticCenter",
        "setColorGalacticCenter",
        "setFlagSupergalacticPoles",
        "getFlagSupergalacticPoles",
        "getColorSupergalacticPoles",
        "setColorSupergalacticPoles",
        "setFlagEquinoxJ2000Points",
        "getFlagEquinoxJ2000Points",
        "getColorEquinoxJ2000Points",
        "setColorEquinoxJ2000Points",
        "setFlagEquinoxPoints",
        "getFlagEquinoxPoints",
        "getColorEquinoxPoints",
        "setColorEquinoxPoints",
        "setFlagSolsticeJ2000Points",
        "getFlagSolsticeJ2000Points",
        "getColorSolsticeJ2000Points",
        "setColorSolsticeJ2000Points",
        "setFlagSolsticePoints",
        "getFlagSolsticePoints",
        "getColorSolsticePoints",
        "setColorSolsticePoints",
        "setFlagAntisolarPoint",
        "getFlagAntisolarPoint",
        "getColorAntisolarPoint",
        "setColorAntisolarPoint",
        "setFlagUmbraCenterPoint",
        "getFlagUmbraCenterPoint",
        "setFlagApexPoints",
        "getFlagApexPoints",
        "getColorApexPoints",
        "setColorApexPoints",
        "setLineThickness",
        "thickness",
        "getLineThickness",
        "setPartThickness",
        "getPartThickness",
        "setPointSize",
        "size",
        "getPointSize",
        "getGridSpacingMultiplier",
        "setGridSpacingMultiplier",
        "updateLabels",
        "connectSolarSystem",
        "setFontSizeFromApp",
        "gridlinesDisplayed",
        "azimuthalGridDisplayed",
        "azimuthalGridColor",
        "equatorGridDisplayed",
        "equatorGridColor",
        "fixedEquatorGridDisplayed",
        "fixedEquatorGridColor",
        "equatorJ2000GridDisplayed",
        "equatorJ2000GridColor",
        "eclipticJ2000GridDisplayed",
        "eclipticJ2000GridColor",
        "eclipticGridDisplayed",
        "eclipticGridColor",
        "galacticGridDisplayed",
        "galacticGridColor",
        "supergalacticGridDisplayed",
        "supergalacticGridColor",
        "equatorLineDisplayed",
        "equatorPartsDisplayed",
        "equatorPartsLabeled",
        "equatorLineColor",
        "equatorJ2000LineDisplayed",
        "equatorJ2000PartsDisplayed",
        "equatorJ2000PartsLabeled",
        "equatorJ2000LineColor",
        "fixedEquatorLineDisplayed",
        "fixedEquatorPartsDisplayed",
        "fixedEquatorPartsLabeled",
        "fixedEquatorLineColor",
        "eclipticLineDisplayed",
        "eclipticPartsDisplayed",
        "eclipticPartsLabeled",
        "eclipticDatesLabeled",
        "eclipticLineColor",
        "eclipticJ2000LineDisplayed",
        "eclipticJ2000PartsDisplayed",
        "eclipticJ2000PartsLabeled",
        "eclipticJ2000LineColor",
        "invariablePlaneLineDisplayed",
        "invariablePlaneLineColor",
        "solarEquatorLineDisplayed",
        "solarEquatorPartsDisplayed",
        "solarEquatorPartsLabeled",
        "solarEquatorLineColor",
        "precessionCirclesDisplayed",
        "precessionPartsDisplayed",
        "precessionPartsLabeled",
        "precessionCirclesColor",
        "meridianLineDisplayed",
        "meridianPartsDisplayed",
        "meridianPartsLabeled",
        "meridianLineColor",
        "longitudeLineDisplayed",
        "longitudePartsDisplayed",
        "longitudePartsLabeled",
        "longitudeLineColor",
        "quadratureLineDisplayed",
        "quadratureLineColor",
        "horizonLineDisplayed",
        "horizonPartsDisplayed",
        "horizonPartsLabeled",
        "horizonLineColor",
        "galacticEquatorLineDisplayed",
        "galacticEquatorPartsDisplayed",
        "galacticEquatorPartsLabeled",
        "galacticEquatorLineColor",
        "supergalacticEquatorLineDisplayed",
        "supergalacticEquatorPartsDisplayed",
        "supergalacticEquatorPartsLabeled",
        "supergalacticEquatorLineColor",
        "primeVerticalLineDisplayed",
        "primeVerticalPartsDisplayed",
        "primeVerticalPartsLabeled",
        "primeVerticalLineColor",
        "currentVerticalLineDisplayed",
        "currentVerticalPartsDisplayed",
        "currentVerticalPartsLabeled",
        "currentVerticalLineColor",
        "colureLinesDisplayed",
        "colurePartsDisplayed",
        "colurePartsLabeled",
        "colureLinesColor",
        "circumpolarCirclesDisplayed",
        "circumpolarCirclesColor",
        "umbraCircleDisplayed",
        "umbraCircleColor",
        "penumbraCircleDisplayed",
        "penumbraCircleColor",
        "celestialJ2000PolesDisplayed",
        "celestialJ2000PolesColor",
        "celestialPolesDisplayed",
        "celestialPolesColor",
        "zenithNadirDisplayed",
        "zenithNadirColor",
        "eclipticJ2000PolesDisplayed",
        "eclipticJ2000PolesColor",
        "eclipticPolesDisplayed",
        "eclipticPolesColor",
        "galacticPolesDisplayed",
        "galacticPolesColor",
        "galacticCenterDisplayed",
        "galacticCenterColor",
        "supergalacticPolesDisplayed",
        "supergalacticPolesColor",
        "equinoxJ2000PointsDisplayed",
        "equinoxJ2000PointsColor",
        "equinoxPointsDisplayed",
        "equinoxPointsColor",
        "solsticeJ2000PointsDisplayed",
        "solsticeJ2000PointsColor",
        "solsticePointsDisplayed",
        "solsticePointsColor",
        "antisolarPointDisplayed",
        "antisolarPointColor",
        "umbraCenterPointDisplayed",
        "apexPointsDisplayed",
        "apexPointsColor",
        "lineThickness",
        "partThickness",
        "pointSize",
        "gridSpacingMultiplier"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'gridlinesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'lineThicknessChanged'
        QtMocHelpers::SignalData<void(const float)>(3, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'partThicknessChanged'
        QtMocHelpers::SignalData<void(const float)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'pointSizeChanged'
        QtMocHelpers::SignalData<void(const float)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 2 },
        }}),
        // Signal 'azimuthalGridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'azimuthalGridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'equatorGridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorGridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'fixedEquatorGridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'fixedEquatorGridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'equatorJ2000GridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorJ2000GridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'eclipticGridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticGridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'eclipticJ2000GridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticJ2000GridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'galacticGridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'galacticGridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'supergalacticGridDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'supergalacticGridColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'equatorLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'equatorJ2000LineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorJ2000PartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorJ2000PartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equatorJ2000LineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'fixedEquatorLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'fixedEquatorPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'fixedEquatorPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'fixedEquatorLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'eclipticLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticDatesLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'invariablePlaneLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'invariablePlaneLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'solarEquatorLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'solarEquatorPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'solarEquatorPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'solarEquatorLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'eclipticJ2000LineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticJ2000PartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticJ2000PartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticJ2000LineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'precessionCirclesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'precessionPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'precessionPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'precessionCirclesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'meridianLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'meridianPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'meridianPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'meridianLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'longitudeLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'longitudePartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'longitudePartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'longitudeLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'quadratureLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'quadratureLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'horizonLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'horizonPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'horizonPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'horizonLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'galacticEquatorLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'galacticEquatorPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'galacticEquatorPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'galacticEquatorLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'supergalacticEquatorLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'supergalacticEquatorPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'supergalacticEquatorPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'supergalacticEquatorLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'primeVerticalLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'primeVerticalPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'primeVerticalPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'primeVerticalLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'currentVerticalLineDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'currentVerticalPartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'currentVerticalPartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'currentVerticalLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'colureLinesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'colurePartsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'colurePartsLabeledChanged'
        QtMocHelpers::SignalData<void(const bool)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'colureLinesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'circumpolarCirclesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'circumpolarCirclesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'umbraCircleDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'umbraCircleColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'penumbraCircleDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'penumbraCircleColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'celestialJ2000PolesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'celestialJ2000PolesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(97, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'celestialPolesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'celestialPolesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'zenithNadirDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'zenithNadirColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'eclipticJ2000PolesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticJ2000PolesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'eclipticPolesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'eclipticPolesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'galacticPolesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'galacticPolesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'galacticCenterDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'galacticCenterColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'supergalacticPolesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'supergalacticPolesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'equinoxJ2000PointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equinoxJ2000PointsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'equinoxPointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'equinoxPointsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'solsticeJ2000PointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'solsticeJ2000PointsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'solsticePointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'solsticePointsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'antisolarPointDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'antisolarPointColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'umbraCenterPointDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'apexPointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(123, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Signal 'apexPointsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Signal 'gridSpacingMultiplierChanged'
        QtMocHelpers::SignalData<void(double)>(125, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 126 },
        }}),
        // Slot 'setFlagGridlines'
        QtMocHelpers::SlotData<void(const bool)>(127, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGridlines'
        QtMocHelpers::SlotData<bool() const>(128, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAllGrids'
        QtMocHelpers::SlotData<void(const bool)>(129, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'setFlagAllLines'
        QtMocHelpers::SlotData<void(const bool)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'setFlagAllPoints'
        QtMocHelpers::SlotData<void(const bool)>(131, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'setFlagAzimuthalGrid'
        QtMocHelpers::SlotData<void(const bool)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagAzimuthalGrid'
        QtMocHelpers::SlotData<bool() const>(133, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorAzimuthalGrid'
        QtMocHelpers::SlotData<Vec3f() const>(134, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorAzimuthalGrid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(135, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEquatorGrid'
        QtMocHelpers::SlotData<void(const bool)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorGrid'
        QtMocHelpers::SlotData<bool() const>(137, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEquatorGrid'
        QtMocHelpers::SlotData<Vec3f() const>(138, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEquatorGrid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(139, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagFixedEquatorGrid'
        QtMocHelpers::SlotData<void(const bool)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagFixedEquatorGrid'
        QtMocHelpers::SlotData<bool() const>(141, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorFixedEquatorGrid'
        QtMocHelpers::SlotData<Vec3f() const>(142, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorFixedEquatorGrid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(143, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEquatorJ2000Grid'
        QtMocHelpers::SlotData<void(const bool)>(144, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorJ2000Grid'
        QtMocHelpers::SlotData<bool() const>(145, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEquatorJ2000Grid'
        QtMocHelpers::SlotData<Vec3f() const>(146, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEquatorJ2000Grid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEclipticJ2000Grid'
        QtMocHelpers::SlotData<void(const bool)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticJ2000Grid'
        QtMocHelpers::SlotData<bool() const>(149, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEclipticJ2000Grid'
        QtMocHelpers::SlotData<Vec3f() const>(150, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEclipticJ2000Grid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(151, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEclipticGrid'
        QtMocHelpers::SlotData<void(const bool)>(152, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticGrid'
        QtMocHelpers::SlotData<bool() const>(153, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEclipticGrid'
        QtMocHelpers::SlotData<Vec3f() const>(154, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEclipticGrid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagGalacticGrid'
        QtMocHelpers::SlotData<void(const bool)>(156, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGalacticGrid'
        QtMocHelpers::SlotData<bool() const>(157, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorGalacticGrid'
        QtMocHelpers::SlotData<Vec3f() const>(158, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorGalacticGrid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(159, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagSupergalacticGrid'
        QtMocHelpers::SlotData<void(const bool)>(160, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSupergalacticGrid'
        QtMocHelpers::SlotData<bool() const>(161, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorSupergalacticGrid'
        QtMocHelpers::SlotData<Vec3f() const>(162, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorSupergalacticGrid'
        QtMocHelpers::SlotData<void(const Vec3f &)>(163, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEquatorLine'
        QtMocHelpers::SlotData<void(const bool)>(164, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorLine'
        QtMocHelpers::SlotData<bool() const>(165, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEquatorParts'
        QtMocHelpers::SlotData<void(const bool)>(166, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorParts'
        QtMocHelpers::SlotData<bool() const>(167, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEquatorLabeled'
        QtMocHelpers::SlotData<void(const bool)>(168, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorLabeled'
        QtMocHelpers::SlotData<bool() const>(169, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEquatorLine'
        QtMocHelpers::SlotData<Vec3f() const>(170, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEquatorLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(171, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEquatorJ2000Line'
        QtMocHelpers::SlotData<void(const bool)>(172, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorJ2000Line'
        QtMocHelpers::SlotData<bool() const>(173, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEquatorJ2000Parts'
        QtMocHelpers::SlotData<void(const bool)>(174, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorJ2000Parts'
        QtMocHelpers::SlotData<bool() const>(175, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEquatorJ2000Labeled'
        QtMocHelpers::SlotData<void(const bool)>(176, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquatorJ2000Labeled'
        QtMocHelpers::SlotData<bool() const>(177, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEquatorJ2000Line'
        QtMocHelpers::SlotData<Vec3f() const>(178, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEquatorJ2000Line'
        QtMocHelpers::SlotData<void(const Vec3f &)>(179, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagFixedEquatorLine'
        QtMocHelpers::SlotData<void(const bool)>(180, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagFixedEquatorLine'
        QtMocHelpers::SlotData<bool() const>(181, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagFixedEquatorParts'
        QtMocHelpers::SlotData<void(const bool)>(182, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagFixedEquatorParts'
        QtMocHelpers::SlotData<bool() const>(183, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagFixedEquatorLabeled'
        QtMocHelpers::SlotData<void(const bool)>(184, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagFixedEquatorLabeled'
        QtMocHelpers::SlotData<bool() const>(185, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorFixedEquatorLine'
        QtMocHelpers::SlotData<Vec3f() const>(186, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorFixedEquatorLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEclipticJ2000Line'
        QtMocHelpers::SlotData<void(const bool)>(188, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticJ2000Line'
        QtMocHelpers::SlotData<bool() const>(189, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEclipticJ2000Parts'
        QtMocHelpers::SlotData<void(const bool)>(190, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticJ2000Parts'
        QtMocHelpers::SlotData<bool() const>(191, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEclipticJ2000Labeled'
        QtMocHelpers::SlotData<void(const bool)>(192, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticJ2000Labeled'
        QtMocHelpers::SlotData<bool() const>(193, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEclipticJ2000Line'
        QtMocHelpers::SlotData<Vec3f() const>(194, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEclipticJ2000Line'
        QtMocHelpers::SlotData<void(const Vec3f &)>(195, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEclipticLine'
        QtMocHelpers::SlotData<void(const bool)>(196, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticLine'
        QtMocHelpers::SlotData<bool() const>(197, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEclipticParts'
        QtMocHelpers::SlotData<void(const bool)>(198, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticParts'
        QtMocHelpers::SlotData<bool() const>(199, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEclipticLabeled'
        QtMocHelpers::SlotData<void(const bool)>(200, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticLabeled'
        QtMocHelpers::SlotData<bool() const>(201, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEclipticDatesLabeled'
        QtMocHelpers::SlotData<void(const bool)>(202, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticDatesLabeled'
        QtMocHelpers::SlotData<bool() const>(203, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEclipticLine'
        QtMocHelpers::SlotData<Vec3f() const>(204, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEclipticLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(205, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagInvariablePlaneLine'
        QtMocHelpers::SlotData<void(const bool)>(206, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagInvariablePlaneLine'
        QtMocHelpers::SlotData<bool() const>(207, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorInvariablePlaneLine'
        QtMocHelpers::SlotData<Vec3f() const>(208, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorInvariablePlaneLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(209, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagSolarEquatorLine'
        QtMocHelpers::SlotData<void(const bool)>(210, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSolarEquatorLine'
        QtMocHelpers::SlotData<bool() const>(211, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSolarEquatorParts'
        QtMocHelpers::SlotData<void(const bool)>(212, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSolarEquatorParts'
        QtMocHelpers::SlotData<bool() const>(213, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSolarEquatorLabeled'
        QtMocHelpers::SlotData<void(const bool)>(214, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSolarEquatorLabeled'
        QtMocHelpers::SlotData<bool() const>(215, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorSolarEquatorLine'
        QtMocHelpers::SlotData<Vec3f() const>(216, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorSolarEquatorLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(217, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagPrecessionCircles'
        QtMocHelpers::SlotData<void(const bool)>(218, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPrecessionCircles'
        QtMocHelpers::SlotData<bool() const>(219, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPrecessionParts'
        QtMocHelpers::SlotData<void(const bool)>(220, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPrecessionParts'
        QtMocHelpers::SlotData<bool() const>(221, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPrecessionLabeled'
        QtMocHelpers::SlotData<void(const bool)>(222, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPrecessionLabeled'
        QtMocHelpers::SlotData<bool() const>(223, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorPrecessionCircles'
        QtMocHelpers::SlotData<Vec3f() const>(224, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorPrecessionCircles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(225, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagMeridianLine'
        QtMocHelpers::SlotData<void(const bool)>(226, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagMeridianLine'
        QtMocHelpers::SlotData<bool() const>(227, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagMeridianParts'
        QtMocHelpers::SlotData<void(const bool)>(228, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagMeridianParts'
        QtMocHelpers::SlotData<bool() const>(229, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagMeridianLabeled'
        QtMocHelpers::SlotData<void(const bool)>(230, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagMeridianLabeled'
        QtMocHelpers::SlotData<bool() const>(231, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorMeridianLine'
        QtMocHelpers::SlotData<Vec3f() const>(232, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorMeridianLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(233, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagLongitudeLine'
        QtMocHelpers::SlotData<void(const bool)>(234, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagLongitudeLine'
        QtMocHelpers::SlotData<bool() const>(235, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLongitudeParts'
        QtMocHelpers::SlotData<void(const bool)>(236, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagLongitudeParts'
        QtMocHelpers::SlotData<bool() const>(237, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLongitudeLabeled'
        QtMocHelpers::SlotData<void(const bool)>(238, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagLongitudeLabeled'
        QtMocHelpers::SlotData<bool() const>(239, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorLongitudeLine'
        QtMocHelpers::SlotData<Vec3f() const>(240, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorLongitudeLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(241, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagQuadratureLine'
        QtMocHelpers::SlotData<void(const bool)>(242, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagQuadratureLine'
        QtMocHelpers::SlotData<bool() const>(243, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorQuadratureLine'
        QtMocHelpers::SlotData<Vec3f() const>(244, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorQuadratureLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(245, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagHorizonLine'
        QtMocHelpers::SlotData<void(const bool)>(246, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagHorizonLine'
        QtMocHelpers::SlotData<bool() const>(247, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagHorizonParts'
        QtMocHelpers::SlotData<void(const bool)>(248, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagHorizonParts'
        QtMocHelpers::SlotData<bool() const>(249, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagHorizonLabeled'
        QtMocHelpers::SlotData<void(const bool)>(250, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagHorizonLabeled'
        QtMocHelpers::SlotData<bool() const>(251, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorHorizonLine'
        QtMocHelpers::SlotData<Vec3f() const>(252, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorHorizonLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(253, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagGalacticEquatorLine'
        QtMocHelpers::SlotData<void(const bool)>(254, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGalacticEquatorLine'
        QtMocHelpers::SlotData<bool() const>(255, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagGalacticEquatorParts'
        QtMocHelpers::SlotData<void(const bool)>(256, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGalacticEquatorParts'
        QtMocHelpers::SlotData<bool() const>(257, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagGalacticEquatorLabeled'
        QtMocHelpers::SlotData<void(const bool)>(258, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGalacticEquatorLabeled'
        QtMocHelpers::SlotData<bool() const>(259, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorGalacticEquatorLine'
        QtMocHelpers::SlotData<Vec3f() const>(260, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorGalacticEquatorLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(261, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagSupergalacticEquatorLine'
        QtMocHelpers::SlotData<void(const bool)>(262, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSupergalacticEquatorLine'
        QtMocHelpers::SlotData<bool() const>(263, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSupergalacticEquatorParts'
        QtMocHelpers::SlotData<void(const bool)>(264, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSupergalacticEquatorParts'
        QtMocHelpers::SlotData<bool() const>(265, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSupergalacticEquatorLabeled'
        QtMocHelpers::SlotData<void(const bool)>(266, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSupergalacticEquatorLabeled'
        QtMocHelpers::SlotData<bool() const>(267, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorSupergalacticEquatorLine'
        QtMocHelpers::SlotData<Vec3f() const>(268, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorSupergalacticEquatorLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(269, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagPrimeVerticalLine'
        QtMocHelpers::SlotData<void(const bool)>(270, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPrimeVerticalLine'
        QtMocHelpers::SlotData<bool() const>(271, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPrimeVerticalParts'
        QtMocHelpers::SlotData<void(const bool)>(272, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPrimeVerticalParts'
        QtMocHelpers::SlotData<bool() const>(273, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPrimeVerticalLabeled'
        QtMocHelpers::SlotData<void(const bool)>(274, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPrimeVerticalLabeled'
        QtMocHelpers::SlotData<bool() const>(275, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorPrimeVerticalLine'
        QtMocHelpers::SlotData<Vec3f() const>(276, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorPrimeVerticalLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(277, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagCurrentVerticalLine'
        QtMocHelpers::SlotData<void(const bool)>(278, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagCurrentVerticalLine'
        QtMocHelpers::SlotData<bool() const>(279, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagCurrentVerticalParts'
        QtMocHelpers::SlotData<void(const bool)>(280, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagCurrentVerticalParts'
        QtMocHelpers::SlotData<bool() const>(281, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagCurrentVerticalLabeled'
        QtMocHelpers::SlotData<void(const bool)>(282, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagCurrentVerticalLabeled'
        QtMocHelpers::SlotData<bool() const>(283, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorCurrentVerticalLine'
        QtMocHelpers::SlotData<Vec3f() const>(284, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorCurrentVerticalLine'
        QtMocHelpers::SlotData<void(const Vec3f &)>(285, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagColureLines'
        QtMocHelpers::SlotData<void(const bool)>(286, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagColureLines'
        QtMocHelpers::SlotData<bool() const>(287, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagColureParts'
        QtMocHelpers::SlotData<void(const bool)>(288, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagColureParts'
        QtMocHelpers::SlotData<bool() const>(289, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagColureLabeled'
        QtMocHelpers::SlotData<void(const bool)>(290, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagColureLabeled'
        QtMocHelpers::SlotData<bool() const>(291, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorColureLines'
        QtMocHelpers::SlotData<Vec3f() const>(292, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorColureLines'
        QtMocHelpers::SlotData<void(const Vec3f &)>(293, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagCircumpolarCircles'
        QtMocHelpers::SlotData<void(const bool)>(294, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagCircumpolarCircles'
        QtMocHelpers::SlotData<bool() const>(295, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorCircumpolarCircles'
        QtMocHelpers::SlotData<Vec3f() const>(296, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorCircumpolarCircles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(297, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagUmbraCircle'
        QtMocHelpers::SlotData<void(const bool)>(298, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagUmbraCircle'
        QtMocHelpers::SlotData<bool() const>(299, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorUmbraCircle'
        QtMocHelpers::SlotData<Vec3f() const>(300, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorUmbraCircle'
        QtMocHelpers::SlotData<void(const Vec3f &)>(301, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagPenumbraCircle'
        QtMocHelpers::SlotData<void(const bool)>(302, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagPenumbraCircle'
        QtMocHelpers::SlotData<bool() const>(303, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorPenumbraCircle'
        QtMocHelpers::SlotData<Vec3f() const>(304, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorPenumbraCircle'
        QtMocHelpers::SlotData<void(const Vec3f &)>(305, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagCelestialJ2000Poles'
        QtMocHelpers::SlotData<void(const bool)>(306, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagCelestialJ2000Poles'
        QtMocHelpers::SlotData<bool() const>(307, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorCelestialJ2000Poles'
        QtMocHelpers::SlotData<Vec3f() const>(308, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorCelestialJ2000Poles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(309, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagCelestialPoles'
        QtMocHelpers::SlotData<void(const bool)>(310, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagCelestialPoles'
        QtMocHelpers::SlotData<bool() const>(311, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorCelestialPoles'
        QtMocHelpers::SlotData<Vec3f() const>(312, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorCelestialPoles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(313, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagZenithNadir'
        QtMocHelpers::SlotData<void(const bool)>(314, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagZenithNadir'
        QtMocHelpers::SlotData<bool() const>(315, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorZenithNadir'
        QtMocHelpers::SlotData<Vec3f() const>(316, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorZenithNadir'
        QtMocHelpers::SlotData<void(const Vec3f &)>(317, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEclipticJ2000Poles'
        QtMocHelpers::SlotData<void(const bool)>(318, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticJ2000Poles'
        QtMocHelpers::SlotData<bool() const>(319, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEclipticJ2000Poles'
        QtMocHelpers::SlotData<Vec3f() const>(320, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEclipticJ2000Poles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(321, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEclipticPoles'
        QtMocHelpers::SlotData<void(const bool)>(322, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEclipticPoles'
        QtMocHelpers::SlotData<bool() const>(323, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEclipticPoles'
        QtMocHelpers::SlotData<Vec3f() const>(324, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEclipticPoles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(325, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagGalacticPoles'
        QtMocHelpers::SlotData<void(const bool)>(326, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGalacticPoles'
        QtMocHelpers::SlotData<bool() const>(327, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorGalacticPoles'
        QtMocHelpers::SlotData<Vec3f() const>(328, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorGalacticPoles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(329, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagGalacticCenter'
        QtMocHelpers::SlotData<void(const bool)>(330, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagGalacticCenter'
        QtMocHelpers::SlotData<bool() const>(331, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorGalacticCenter'
        QtMocHelpers::SlotData<Vec3f() const>(332, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorGalacticCenter'
        QtMocHelpers::SlotData<void(const Vec3f &)>(333, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagSupergalacticPoles'
        QtMocHelpers::SlotData<void(const bool)>(334, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSupergalacticPoles'
        QtMocHelpers::SlotData<bool() const>(335, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorSupergalacticPoles'
        QtMocHelpers::SlotData<Vec3f() const>(336, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorSupergalacticPoles'
        QtMocHelpers::SlotData<void(const Vec3f &)>(337, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEquinoxJ2000Points'
        QtMocHelpers::SlotData<void(const bool)>(338, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquinoxJ2000Points'
        QtMocHelpers::SlotData<bool() const>(339, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEquinoxJ2000Points'
        QtMocHelpers::SlotData<Vec3f() const>(340, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEquinoxJ2000Points'
        QtMocHelpers::SlotData<void(const Vec3f &)>(341, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagEquinoxPoints'
        QtMocHelpers::SlotData<void(const bool)>(342, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagEquinoxPoints'
        QtMocHelpers::SlotData<bool() const>(343, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorEquinoxPoints'
        QtMocHelpers::SlotData<Vec3f() const>(344, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorEquinoxPoints'
        QtMocHelpers::SlotData<void(const Vec3f &)>(345, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagSolsticeJ2000Points'
        QtMocHelpers::SlotData<void(const bool)>(346, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSolsticeJ2000Points'
        QtMocHelpers::SlotData<bool() const>(347, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorSolsticeJ2000Points'
        QtMocHelpers::SlotData<Vec3f() const>(348, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorSolsticeJ2000Points'
        QtMocHelpers::SlotData<void(const Vec3f &)>(349, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagSolsticePoints'
        QtMocHelpers::SlotData<void(const bool)>(350, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagSolsticePoints'
        QtMocHelpers::SlotData<bool() const>(351, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorSolsticePoints'
        QtMocHelpers::SlotData<Vec3f() const>(352, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorSolsticePoints'
        QtMocHelpers::SlotData<void(const Vec3f &)>(353, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagAntisolarPoint'
        QtMocHelpers::SlotData<void(const bool)>(354, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagAntisolarPoint'
        QtMocHelpers::SlotData<bool() const>(355, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorAntisolarPoint'
        QtMocHelpers::SlotData<Vec3f() const>(356, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorAntisolarPoint'
        QtMocHelpers::SlotData<void(const Vec3f &)>(357, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setFlagUmbraCenterPoint'
        QtMocHelpers::SlotData<void(const bool)>(358, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagUmbraCenterPoint'
        QtMocHelpers::SlotData<bool() const>(359, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagApexPoints'
        QtMocHelpers::SlotData<void(const bool)>(360, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 11 },
        }}),
        // Slot 'getFlagApexPoints'
        QtMocHelpers::SlotData<bool() const>(361, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getColorApexPoints'
        QtMocHelpers::SlotData<Vec3f() const>(362, 2, QMC::AccessPublic, 0x80000000 | 8),
        // Slot 'setColorApexPoints'
        QtMocHelpers::SlotData<void(const Vec3f &)>(363, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'setLineThickness'
        QtMocHelpers::SlotData<void(const float)>(364, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 365 },
        }}),
        // Slot 'getLineThickness'
        QtMocHelpers::SlotData<float() const>(366, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setPartThickness'
        QtMocHelpers::SlotData<void(const float)>(367, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 365 },
        }}),
        // Slot 'getPartThickness'
        QtMocHelpers::SlotData<float() const>(368, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setPointSize'
        QtMocHelpers::SlotData<void(const float)>(369, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 370 },
        }}),
        // Slot 'getPointSize'
        QtMocHelpers::SlotData<float() const>(371, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'getGridSpacingMultiplier'
        QtMocHelpers::SlotData<double() const>(372, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setGridSpacingMultiplier'
        QtMocHelpers::SlotData<void(double)>(373, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 126 },
        }}),
        // Slot 'updateLabels'
        QtMocHelpers::SlotData<void()>(374, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'connectSolarSystem'
        QtMocHelpers::SlotData<void()>(375, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setFontSizeFromApp'
        QtMocHelpers::SlotData<void(int)>(376, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 370 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'gridlinesDisplayed'
        QtMocHelpers::PropertyData<bool>(377, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'azimuthalGridDisplayed'
        QtMocHelpers::PropertyData<bool>(378, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 4),
        // property 'azimuthalGridColor'
        QtMocHelpers::PropertyData<Vec3f>(379, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 5),
        // property 'equatorGridDisplayed'
        QtMocHelpers::PropertyData<bool>(380, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 6),
        // property 'equatorGridColor'
        QtMocHelpers::PropertyData<Vec3f>(381, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 7),
        // property 'fixedEquatorGridDisplayed'
        QtMocHelpers::PropertyData<bool>(382, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 8),
        // property 'fixedEquatorGridColor'
        QtMocHelpers::PropertyData<Vec3f>(383, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 9),
        // property 'equatorJ2000GridDisplayed'
        QtMocHelpers::PropertyData<bool>(384, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 10),
        // property 'equatorJ2000GridColor'
        QtMocHelpers::PropertyData<Vec3f>(385, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 11),
        // property 'eclipticJ2000GridDisplayed'
        QtMocHelpers::PropertyData<bool>(386, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 14),
        // property 'eclipticJ2000GridColor'
        QtMocHelpers::PropertyData<Vec3f>(387, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 15),
        // property 'eclipticGridDisplayed'
        QtMocHelpers::PropertyData<bool>(388, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'eclipticGridColor'
        QtMocHelpers::PropertyData<Vec3f>(389, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 13),
        // property 'galacticGridDisplayed'
        QtMocHelpers::PropertyData<bool>(390, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 16),
        // property 'galacticGridColor'
        QtMocHelpers::PropertyData<Vec3f>(391, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 17),
        // property 'supergalacticGridDisplayed'
        QtMocHelpers::PropertyData<bool>(392, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 18),
        // property 'supergalacticGridColor'
        QtMocHelpers::PropertyData<Vec3f>(393, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 19),
        // property 'equatorLineDisplayed'
        QtMocHelpers::PropertyData<bool>(394, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 20),
        // property 'equatorPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(395, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 21),
        // property 'equatorPartsLabeled'
        QtMocHelpers::PropertyData<bool>(396, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 22),
        // property 'equatorLineColor'
        QtMocHelpers::PropertyData<Vec3f>(397, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 23),
        // property 'equatorJ2000LineDisplayed'
        QtMocHelpers::PropertyData<bool>(398, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 24),
        // property 'equatorJ2000PartsDisplayed'
        QtMocHelpers::PropertyData<bool>(399, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 25),
        // property 'equatorJ2000PartsLabeled'
        QtMocHelpers::PropertyData<bool>(400, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 26),
        // property 'equatorJ2000LineColor'
        QtMocHelpers::PropertyData<Vec3f>(401, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 27),
        // property 'fixedEquatorLineDisplayed'
        QtMocHelpers::PropertyData<bool>(402, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 28),
        // property 'fixedEquatorPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(403, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 29),
        // property 'fixedEquatorPartsLabeled'
        QtMocHelpers::PropertyData<bool>(404, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 30),
        // property 'fixedEquatorLineColor'
        QtMocHelpers::PropertyData<Vec3f>(405, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 31),
        // property 'eclipticLineDisplayed'
        QtMocHelpers::PropertyData<bool>(406, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 32),
        // property 'eclipticPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(407, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 33),
        // property 'eclipticPartsLabeled'
        QtMocHelpers::PropertyData<bool>(408, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 34),
        // property 'eclipticDatesLabeled'
        QtMocHelpers::PropertyData<bool>(409, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 35),
        // property 'eclipticLineColor'
        QtMocHelpers::PropertyData<Vec3f>(410, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 36),
        // property 'eclipticJ2000LineDisplayed'
        QtMocHelpers::PropertyData<bool>(411, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 43),
        // property 'eclipticJ2000PartsDisplayed'
        QtMocHelpers::PropertyData<bool>(412, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 44),
        // property 'eclipticJ2000PartsLabeled'
        QtMocHelpers::PropertyData<bool>(413, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 45),
        // property 'eclipticJ2000LineColor'
        QtMocHelpers::PropertyData<Vec3f>(414, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 46),
        // property 'invariablePlaneLineDisplayed'
        QtMocHelpers::PropertyData<bool>(415, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 37),
        // property 'invariablePlaneLineColor'
        QtMocHelpers::PropertyData<Vec3f>(416, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 38),
        // property 'solarEquatorLineDisplayed'
        QtMocHelpers::PropertyData<bool>(417, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 39),
        // property 'solarEquatorPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(418, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 40),
        // property 'solarEquatorPartsLabeled'
        QtMocHelpers::PropertyData<bool>(419, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 41),
        // property 'solarEquatorLineColor'
        QtMocHelpers::PropertyData<Vec3f>(420, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 42),
        // property 'precessionCirclesDisplayed'
        QtMocHelpers::PropertyData<bool>(421, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 47),
        // property 'precessionPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(422, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 48),
        // property 'precessionPartsLabeled'
        QtMocHelpers::PropertyData<bool>(423, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 49),
        // property 'precessionCirclesColor'
        QtMocHelpers::PropertyData<Vec3f>(424, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 50),
        // property 'meridianLineDisplayed'
        QtMocHelpers::PropertyData<bool>(425, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 51),
        // property 'meridianPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(426, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 52),
        // property 'meridianPartsLabeled'
        QtMocHelpers::PropertyData<bool>(427, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 53),
        // property 'meridianLineColor'
        QtMocHelpers::PropertyData<Vec3f>(428, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 54),
        // property 'longitudeLineDisplayed'
        QtMocHelpers::PropertyData<bool>(429, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 55),
        // property 'longitudePartsDisplayed'
        QtMocHelpers::PropertyData<bool>(430, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 56),
        // property 'longitudePartsLabeled'
        QtMocHelpers::PropertyData<bool>(431, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 57),
        // property 'longitudeLineColor'
        QtMocHelpers::PropertyData<Vec3f>(432, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 58),
        // property 'quadratureLineDisplayed'
        QtMocHelpers::PropertyData<bool>(433, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 59),
        // property 'quadratureLineColor'
        QtMocHelpers::PropertyData<Vec3f>(434, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 60),
        // property 'horizonLineDisplayed'
        QtMocHelpers::PropertyData<bool>(435, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 61),
        // property 'horizonPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(436, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 62),
        // property 'horizonPartsLabeled'
        QtMocHelpers::PropertyData<bool>(437, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 63),
        // property 'horizonLineColor'
        QtMocHelpers::PropertyData<Vec3f>(438, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 64),
        // property 'galacticEquatorLineDisplayed'
        QtMocHelpers::PropertyData<bool>(439, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 65),
        // property 'galacticEquatorPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(440, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 66),
        // property 'galacticEquatorPartsLabeled'
        QtMocHelpers::PropertyData<bool>(441, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 67),
        // property 'galacticEquatorLineColor'
        QtMocHelpers::PropertyData<Vec3f>(442, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 68),
        // property 'supergalacticEquatorLineDisplayed'
        QtMocHelpers::PropertyData<bool>(443, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 69),
        // property 'supergalacticEquatorPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(444, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 70),
        // property 'supergalacticEquatorPartsLabeled'
        QtMocHelpers::PropertyData<bool>(445, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 71),
        // property 'supergalacticEquatorLineColor'
        QtMocHelpers::PropertyData<Vec3f>(446, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 72),
        // property 'primeVerticalLineDisplayed'
        QtMocHelpers::PropertyData<bool>(447, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 73),
        // property 'primeVerticalPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(448, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 74),
        // property 'primeVerticalPartsLabeled'
        QtMocHelpers::PropertyData<bool>(449, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 75),
        // property 'primeVerticalLineColor'
        QtMocHelpers::PropertyData<Vec3f>(450, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 76),
        // property 'currentVerticalLineDisplayed'
        QtMocHelpers::PropertyData<bool>(451, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 77),
        // property 'currentVerticalPartsDisplayed'
        QtMocHelpers::PropertyData<bool>(452, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 78),
        // property 'currentVerticalPartsLabeled'
        QtMocHelpers::PropertyData<bool>(453, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 79),
        // property 'currentVerticalLineColor'
        QtMocHelpers::PropertyData<Vec3f>(454, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 80),
        // property 'colureLinesDisplayed'
        QtMocHelpers::PropertyData<bool>(455, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 81),
        // property 'colurePartsDisplayed'
        QtMocHelpers::PropertyData<bool>(456, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 82),
        // property 'colurePartsLabeled'
        QtMocHelpers::PropertyData<bool>(457, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 83),
        // property 'colureLinesColor'
        QtMocHelpers::PropertyData<Vec3f>(458, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 84),
        // property 'circumpolarCirclesDisplayed'
        QtMocHelpers::PropertyData<bool>(459, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 85),
        // property 'circumpolarCirclesColor'
        QtMocHelpers::PropertyData<Vec3f>(460, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 86),
        // property 'umbraCircleDisplayed'
        QtMocHelpers::PropertyData<bool>(461, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 87),
        // property 'umbraCircleColor'
        QtMocHelpers::PropertyData<Vec3f>(462, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 88),
        // property 'penumbraCircleDisplayed'
        QtMocHelpers::PropertyData<bool>(463, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 89),
        // property 'penumbraCircleColor'
        QtMocHelpers::PropertyData<Vec3f>(464, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 90),
        // property 'celestialJ2000PolesDisplayed'
        QtMocHelpers::PropertyData<bool>(465, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 91),
        // property 'celestialJ2000PolesColor'
        QtMocHelpers::PropertyData<Vec3f>(466, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 92),
        // property 'celestialPolesDisplayed'
        QtMocHelpers::PropertyData<bool>(467, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 93),
        // property 'celestialPolesColor'
        QtMocHelpers::PropertyData<Vec3f>(468, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 94),
        // property 'zenithNadirDisplayed'
        QtMocHelpers::PropertyData<bool>(469, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 95),
        // property 'zenithNadirColor'
        QtMocHelpers::PropertyData<Vec3f>(470, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 96),
        // property 'eclipticJ2000PolesDisplayed'
        QtMocHelpers::PropertyData<bool>(471, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 97),
        // property 'eclipticJ2000PolesColor'
        QtMocHelpers::PropertyData<Vec3f>(472, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 98),
        // property 'eclipticPolesDisplayed'
        QtMocHelpers::PropertyData<bool>(473, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 99),
        // property 'eclipticPolesColor'
        QtMocHelpers::PropertyData<Vec3f>(474, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 100),
        // property 'galacticPolesDisplayed'
        QtMocHelpers::PropertyData<bool>(475, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 101),
        // property 'galacticPolesColor'
        QtMocHelpers::PropertyData<Vec3f>(476, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 102),
        // property 'galacticCenterDisplayed'
        QtMocHelpers::PropertyData<bool>(477, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 103),
        // property 'galacticCenterColor'
        QtMocHelpers::PropertyData<Vec3f>(478, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 104),
        // property 'supergalacticPolesDisplayed'
        QtMocHelpers::PropertyData<bool>(479, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 105),
        // property 'supergalacticPolesColor'
        QtMocHelpers::PropertyData<Vec3f>(480, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 106),
        // property 'equinoxJ2000PointsDisplayed'
        QtMocHelpers::PropertyData<bool>(481, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 107),
        // property 'equinoxJ2000PointsColor'
        QtMocHelpers::PropertyData<Vec3f>(482, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 108),
        // property 'equinoxPointsDisplayed'
        QtMocHelpers::PropertyData<bool>(483, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 109),
        // property 'equinoxPointsColor'
        QtMocHelpers::PropertyData<Vec3f>(484, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 110),
        // property 'solsticeJ2000PointsDisplayed'
        QtMocHelpers::PropertyData<bool>(485, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 111),
        // property 'solsticeJ2000PointsColor'
        QtMocHelpers::PropertyData<Vec3f>(486, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 112),
        // property 'solsticePointsDisplayed'
        QtMocHelpers::PropertyData<bool>(487, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 113),
        // property 'solsticePointsColor'
        QtMocHelpers::PropertyData<Vec3f>(488, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 114),
        // property 'antisolarPointDisplayed'
        QtMocHelpers::PropertyData<bool>(489, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 115),
        // property 'antisolarPointColor'
        QtMocHelpers::PropertyData<Vec3f>(490, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 116),
        // property 'umbraCenterPointDisplayed'
        QtMocHelpers::PropertyData<bool>(491, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 117),
        // property 'apexPointsDisplayed'
        QtMocHelpers::PropertyData<bool>(492, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 118),
        // property 'apexPointsColor'
        QtMocHelpers::PropertyData<Vec3f>(493, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 119),
        // property 'lineThickness'
        QtMocHelpers::PropertyData<float>(494, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'partThickness'
        QtMocHelpers::PropertyData<float>(495, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'pointSize'
        QtMocHelpers::PropertyData<float>(496, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'gridSpacingMultiplier'
        QtMocHelpers::PropertyData<double>(497, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 120),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<GridLinesMgr, qt_meta_tag_ZN12GridLinesMgrE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject GridLinesMgr::staticMetaObject = { {
    QMetaObject::SuperData::link<StelModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12GridLinesMgrE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12GridLinesMgrE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12GridLinesMgrE_t>.metaTypes,
    nullptr
} };

void GridLinesMgr::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<GridLinesMgr *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->gridlinesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->lineThicknessChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 2: _t->partThicknessChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 3: _t->pointSizeChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 4: _t->azimuthalGridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->azimuthalGridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 6: _t->equatorGridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->equatorGridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 8: _t->fixedEquatorGridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->fixedEquatorGridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 10: _t->equatorJ2000GridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->equatorJ2000GridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 12: _t->eclipticGridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->eclipticGridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 14: _t->eclipticJ2000GridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->eclipticJ2000GridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 16: _t->galacticGridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->galacticGridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 18: _t->supergalacticGridDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->supergalacticGridColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 20: _t->equatorLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->equatorPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->equatorPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 23: _t->equatorLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 24: _t->equatorJ2000LineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 25: _t->equatorJ2000PartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 26: _t->equatorJ2000PartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->equatorJ2000LineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 28: _t->fixedEquatorLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->fixedEquatorPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->fixedEquatorPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: _t->fixedEquatorLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 32: _t->eclipticLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->eclipticPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 34: _t->eclipticPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->eclipticDatesLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->eclipticLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 37: _t->invariablePlaneLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->invariablePlaneLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 39: _t->solarEquatorLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: _t->solarEquatorPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 41: _t->solarEquatorPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 42: _t->solarEquatorLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 43: _t->eclipticJ2000LineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: _t->eclipticJ2000PartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: _t->eclipticJ2000PartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 46: _t->eclipticJ2000LineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 47: _t->precessionCirclesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: _t->precessionPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 49: _t->precessionPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 50: _t->precessionCirclesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 51: _t->meridianLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 52: _t->meridianPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 53: _t->meridianPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: _t->meridianLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 55: _t->longitudeLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 56: _t->longitudePartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 57: _t->longitudePartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 58: _t->longitudeLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 59: _t->quadratureLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 60: _t->quadratureLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 61: _t->horizonLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 62: _t->horizonPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 63: _t->horizonPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: _t->horizonLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 65: _t->galacticEquatorLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 66: _t->galacticEquatorPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 67: _t->galacticEquatorPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 68: _t->galacticEquatorLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 69: _t->supergalacticEquatorLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 70: _t->supergalacticEquatorPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 71: _t->supergalacticEquatorPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 72: _t->supergalacticEquatorLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 73: _t->primeVerticalLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 74: _t->primeVerticalPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 75: _t->primeVerticalPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 76: _t->primeVerticalLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 77: _t->currentVerticalLineDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 78: _t->currentVerticalPartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 79: _t->currentVerticalPartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 80: _t->currentVerticalLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 81: _t->colureLinesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 82: _t->colurePartsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 83: _t->colurePartsLabeledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 84: _t->colureLinesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 85: _t->circumpolarCirclesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 86: _t->circumpolarCirclesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 87: _t->umbraCircleDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 88: _t->umbraCircleColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 89: _t->penumbraCircleDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 90: _t->penumbraCircleColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 91: _t->celestialJ2000PolesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 92: _t->celestialJ2000PolesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 93: _t->celestialPolesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 94: _t->celestialPolesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 95: _t->zenithNadirDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 96: _t->zenithNadirColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 97: _t->eclipticJ2000PolesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 98: _t->eclipticJ2000PolesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 99: _t->eclipticPolesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 100: _t->eclipticPolesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 101: _t->galacticPolesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 102: _t->galacticPolesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 103: _t->galacticCenterDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 104: _t->galacticCenterColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 105: _t->supergalacticPolesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 106: _t->supergalacticPolesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 107: _t->equinoxJ2000PointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 108: _t->equinoxJ2000PointsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 109: _t->equinoxPointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 110: _t->equinoxPointsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 111: _t->solsticeJ2000PointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 112: _t->solsticeJ2000PointsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 113: _t->solsticePointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 114: _t->solsticePointsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 115: _t->antisolarPointDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 116: _t->antisolarPointColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 117: _t->umbraCenterPointDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 118: _t->apexPointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 119: _t->apexPointsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 120: _t->gridSpacingMultiplierChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 121: _t->setFlagGridlines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 122: { bool _r = _t->getFlagGridlines();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 123: _t->setFlagAllGrids((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 124: _t->setFlagAllLines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 125: _t->setFlagAllPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 126: _t->setFlagAzimuthalGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 127: { bool _r = _t->getFlagAzimuthalGrid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 128: { Vec3f _r = _t->getColorAzimuthalGrid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 129: _t->setColorAzimuthalGrid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 130: _t->setFlagEquatorGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 131: { bool _r = _t->getFlagEquatorGrid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 132: { Vec3f _r = _t->getColorEquatorGrid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 133: _t->setColorEquatorGrid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 134: _t->setFlagFixedEquatorGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 135: { bool _r = _t->getFlagFixedEquatorGrid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 136: { Vec3f _r = _t->getColorFixedEquatorGrid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 137: _t->setColorFixedEquatorGrid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 138: _t->setFlagEquatorJ2000Grid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 139: { bool _r = _t->getFlagEquatorJ2000Grid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 140: { Vec3f _r = _t->getColorEquatorJ2000Grid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 141: _t->setColorEquatorJ2000Grid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 142: _t->setFlagEclipticJ2000Grid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 143: { bool _r = _t->getFlagEclipticJ2000Grid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 144: { Vec3f _r = _t->getColorEclipticJ2000Grid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 145: _t->setColorEclipticJ2000Grid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 146: _t->setFlagEclipticGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 147: { bool _r = _t->getFlagEclipticGrid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 148: { Vec3f _r = _t->getColorEclipticGrid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 149: _t->setColorEclipticGrid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 150: _t->setFlagGalacticGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 151: { bool _r = _t->getFlagGalacticGrid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 152: { Vec3f _r = _t->getColorGalacticGrid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 153: _t->setColorGalacticGrid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 154: _t->setFlagSupergalacticGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 155: { bool _r = _t->getFlagSupergalacticGrid();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 156: { Vec3f _r = _t->getColorSupergalacticGrid();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 157: _t->setColorSupergalacticGrid((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 158: _t->setFlagEquatorLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 159: { bool _r = _t->getFlagEquatorLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 160: _t->setFlagEquatorParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 161: { bool _r = _t->getFlagEquatorParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 162: _t->setFlagEquatorLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 163: { bool _r = _t->getFlagEquatorLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 164: { Vec3f _r = _t->getColorEquatorLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 165: _t->setColorEquatorLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 166: _t->setFlagEquatorJ2000Line((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 167: { bool _r = _t->getFlagEquatorJ2000Line();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 168: _t->setFlagEquatorJ2000Parts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 169: { bool _r = _t->getFlagEquatorJ2000Parts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 170: _t->setFlagEquatorJ2000Labeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 171: { bool _r = _t->getFlagEquatorJ2000Labeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 172: { Vec3f _r = _t->getColorEquatorJ2000Line();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 173: _t->setColorEquatorJ2000Line((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 174: _t->setFlagFixedEquatorLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 175: { bool _r = _t->getFlagFixedEquatorLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 176: _t->setFlagFixedEquatorParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 177: { bool _r = _t->getFlagFixedEquatorParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 178: _t->setFlagFixedEquatorLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 179: { bool _r = _t->getFlagFixedEquatorLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 180: { Vec3f _r = _t->getColorFixedEquatorLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 181: _t->setColorFixedEquatorLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 182: _t->setFlagEclipticJ2000Line((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 183: { bool _r = _t->getFlagEclipticJ2000Line();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 184: _t->setFlagEclipticJ2000Parts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 185: { bool _r = _t->getFlagEclipticJ2000Parts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 186: _t->setFlagEclipticJ2000Labeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 187: { bool _r = _t->getFlagEclipticJ2000Labeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 188: { Vec3f _r = _t->getColorEclipticJ2000Line();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 189: _t->setColorEclipticJ2000Line((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 190: _t->setFlagEclipticLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 191: { bool _r = _t->getFlagEclipticLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 192: _t->setFlagEclipticParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 193: { bool _r = _t->getFlagEclipticParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 194: _t->setFlagEclipticLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 195: { bool _r = _t->getFlagEclipticLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 196: _t->setFlagEclipticDatesLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 197: { bool _r = _t->getFlagEclipticDatesLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 198: { Vec3f _r = _t->getColorEclipticLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 199: _t->setColorEclipticLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 200: _t->setFlagInvariablePlaneLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 201: { bool _r = _t->getFlagInvariablePlaneLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 202: { Vec3f _r = _t->getColorInvariablePlaneLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 203: _t->setColorInvariablePlaneLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 204: _t->setFlagSolarEquatorLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 205: { bool _r = _t->getFlagSolarEquatorLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 206: _t->setFlagSolarEquatorParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 207: { bool _r = _t->getFlagSolarEquatorParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 208: _t->setFlagSolarEquatorLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 209: { bool _r = _t->getFlagSolarEquatorLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 210: { Vec3f _r = _t->getColorSolarEquatorLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 211: _t->setColorSolarEquatorLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 212: _t->setFlagPrecessionCircles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 213: { bool _r = _t->getFlagPrecessionCircles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 214: _t->setFlagPrecessionParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 215: { bool _r = _t->getFlagPrecessionParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 216: _t->setFlagPrecessionLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 217: { bool _r = _t->getFlagPrecessionLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 218: { Vec3f _r = _t->getColorPrecessionCircles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 219: _t->setColorPrecessionCircles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 220: _t->setFlagMeridianLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 221: { bool _r = _t->getFlagMeridianLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 222: _t->setFlagMeridianParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 223: { bool _r = _t->getFlagMeridianParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 224: _t->setFlagMeridianLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 225: { bool _r = _t->getFlagMeridianLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 226: { Vec3f _r = _t->getColorMeridianLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 227: _t->setColorMeridianLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 228: _t->setFlagLongitudeLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 229: { bool _r = _t->getFlagLongitudeLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 230: _t->setFlagLongitudeParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 231: { bool _r = _t->getFlagLongitudeParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 232: _t->setFlagLongitudeLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 233: { bool _r = _t->getFlagLongitudeLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 234: { Vec3f _r = _t->getColorLongitudeLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 235: _t->setColorLongitudeLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 236: _t->setFlagQuadratureLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 237: { bool _r = _t->getFlagQuadratureLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 238: { Vec3f _r = _t->getColorQuadratureLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 239: _t->setColorQuadratureLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 240: _t->setFlagHorizonLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 241: { bool _r = _t->getFlagHorizonLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 242: _t->setFlagHorizonParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 243: { bool _r = _t->getFlagHorizonParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 244: _t->setFlagHorizonLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 245: { bool _r = _t->getFlagHorizonLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 246: { Vec3f _r = _t->getColorHorizonLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 247: _t->setColorHorizonLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 248: _t->setFlagGalacticEquatorLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 249: { bool _r = _t->getFlagGalacticEquatorLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 250: _t->setFlagGalacticEquatorParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 251: { bool _r = _t->getFlagGalacticEquatorParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 252: _t->setFlagGalacticEquatorLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 253: { bool _r = _t->getFlagGalacticEquatorLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 254: { Vec3f _r = _t->getColorGalacticEquatorLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 255: _t->setColorGalacticEquatorLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 256: _t->setFlagSupergalacticEquatorLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 257: { bool _r = _t->getFlagSupergalacticEquatorLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 258: _t->setFlagSupergalacticEquatorParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 259: { bool _r = _t->getFlagSupergalacticEquatorParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 260: _t->setFlagSupergalacticEquatorLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 261: { bool _r = _t->getFlagSupergalacticEquatorLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 262: { Vec3f _r = _t->getColorSupergalacticEquatorLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 263: _t->setColorSupergalacticEquatorLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 264: _t->setFlagPrimeVerticalLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 265: { bool _r = _t->getFlagPrimeVerticalLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 266: _t->setFlagPrimeVerticalParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 267: { bool _r = _t->getFlagPrimeVerticalParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 268: _t->setFlagPrimeVerticalLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 269: { bool _r = _t->getFlagPrimeVerticalLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 270: { Vec3f _r = _t->getColorPrimeVerticalLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 271: _t->setColorPrimeVerticalLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 272: _t->setFlagCurrentVerticalLine((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 273: { bool _r = _t->getFlagCurrentVerticalLine();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 274: _t->setFlagCurrentVerticalParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 275: { bool _r = _t->getFlagCurrentVerticalParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 276: _t->setFlagCurrentVerticalLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 277: { bool _r = _t->getFlagCurrentVerticalLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 278: { Vec3f _r = _t->getColorCurrentVerticalLine();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 279: _t->setColorCurrentVerticalLine((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 280: _t->setFlagColureLines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 281: { bool _r = _t->getFlagColureLines();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 282: _t->setFlagColureParts((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 283: { bool _r = _t->getFlagColureParts();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 284: _t->setFlagColureLabeled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 285: { bool _r = _t->getFlagColureLabeled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 286: { Vec3f _r = _t->getColorColureLines();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 287: _t->setColorColureLines((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 288: _t->setFlagCircumpolarCircles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 289: { bool _r = _t->getFlagCircumpolarCircles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 290: { Vec3f _r = _t->getColorCircumpolarCircles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 291: _t->setColorCircumpolarCircles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 292: _t->setFlagUmbraCircle((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 293: { bool _r = _t->getFlagUmbraCircle();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 294: { Vec3f _r = _t->getColorUmbraCircle();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 295: _t->setColorUmbraCircle((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 296: _t->setFlagPenumbraCircle((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 297: { bool _r = _t->getFlagPenumbraCircle();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 298: { Vec3f _r = _t->getColorPenumbraCircle();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 299: _t->setColorPenumbraCircle((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 300: _t->setFlagCelestialJ2000Poles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 301: { bool _r = _t->getFlagCelestialJ2000Poles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 302: { Vec3f _r = _t->getColorCelestialJ2000Poles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 303: _t->setColorCelestialJ2000Poles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 304: _t->setFlagCelestialPoles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 305: { bool _r = _t->getFlagCelestialPoles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 306: { Vec3f _r = _t->getColorCelestialPoles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 307: _t->setColorCelestialPoles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 308: _t->setFlagZenithNadir((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 309: { bool _r = _t->getFlagZenithNadir();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 310: { Vec3f _r = _t->getColorZenithNadir();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 311: _t->setColorZenithNadir((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 312: _t->setFlagEclipticJ2000Poles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 313: { bool _r = _t->getFlagEclipticJ2000Poles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 314: { Vec3f _r = _t->getColorEclipticJ2000Poles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 315: _t->setColorEclipticJ2000Poles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 316: _t->setFlagEclipticPoles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 317: { bool _r = _t->getFlagEclipticPoles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 318: { Vec3f _r = _t->getColorEclipticPoles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 319: _t->setColorEclipticPoles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 320: _t->setFlagGalacticPoles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 321: { bool _r = _t->getFlagGalacticPoles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 322: { Vec3f _r = _t->getColorGalacticPoles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 323: _t->setColorGalacticPoles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 324: _t->setFlagGalacticCenter((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 325: { bool _r = _t->getFlagGalacticCenter();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 326: { Vec3f _r = _t->getColorGalacticCenter();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 327: _t->setColorGalacticCenter((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 328: _t->setFlagSupergalacticPoles((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 329: { bool _r = _t->getFlagSupergalacticPoles();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 330: { Vec3f _r = _t->getColorSupergalacticPoles();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 331: _t->setColorSupergalacticPoles((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 332: _t->setFlagEquinoxJ2000Points((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 333: { bool _r = _t->getFlagEquinoxJ2000Points();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 334: { Vec3f _r = _t->getColorEquinoxJ2000Points();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 335: _t->setColorEquinoxJ2000Points((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 336: _t->setFlagEquinoxPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 337: { bool _r = _t->getFlagEquinoxPoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 338: { Vec3f _r = _t->getColorEquinoxPoints();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 339: _t->setColorEquinoxPoints((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 340: _t->setFlagSolsticeJ2000Points((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 341: { bool _r = _t->getFlagSolsticeJ2000Points();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 342: { Vec3f _r = _t->getColorSolsticeJ2000Points();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 343: _t->setColorSolsticeJ2000Points((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 344: _t->setFlagSolsticePoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 345: { bool _r = _t->getFlagSolsticePoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 346: { Vec3f _r = _t->getColorSolsticePoints();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 347: _t->setColorSolsticePoints((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 348: _t->setFlagAntisolarPoint((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 349: { bool _r = _t->getFlagAntisolarPoint();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 350: { Vec3f _r = _t->getColorAntisolarPoint();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 351: _t->setColorAntisolarPoint((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 352: _t->setFlagUmbraCenterPoint((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 353: { bool _r = _t->getFlagUmbraCenterPoint();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 354: _t->setFlagApexPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 355: { bool _r = _t->getFlagApexPoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 356: { Vec3f _r = _t->getColorApexPoints();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 357: _t->setColorApexPoints((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 358: _t->setLineThickness((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 359: { float _r = _t->getLineThickness();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 360: _t->setPartThickness((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 361: { float _r = _t->getPartThickness();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 362: _t->setPointSize((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 363: { float _r = _t->getPointSize();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 364: { double _r = _t->getGridSpacingMultiplier();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 365: _t->setGridSpacingMultiplier((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 366: _t->updateLabels(); break;
        case 367: _t->connectSolarSystem(); break;
        case 368: _t->setFontSizeFromApp((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 5:
            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 7:
            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 9:
            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 11:
            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 13:
            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 15:
            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 17:
            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 19:
            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 23:
            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 27:
            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 31:
            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 36:
            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 38:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 42:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 46:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 50:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 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 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 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 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 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 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 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 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 86:
            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 88:
            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 90:
            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 92:
            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 94:
            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 96:
            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 98:
            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 100:
            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 102:
            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 104:
            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 106:
            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 108:
            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 110:
            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 112:
            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 114:
            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 116:
            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 119:
            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 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 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 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 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 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 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 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 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 173:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 181:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 189:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 199:
            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 203:
            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 211:
            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 219:
            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 227:
            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 235:
            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 239:
            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 247:
            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 255:
            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 263:
            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 271:
            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 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 291:
            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 295:
            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 299:
            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 303:
            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 307:
            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 311:
            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 315:
            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 319:
            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 323:
            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 327:
            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 331:
            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 335:
            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 339:
            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 343:
            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 347:
            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 351:
            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 357:
            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 (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::gridlinesDisplayedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const float )>(_a, &GridLinesMgr::lineThicknessChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const float )>(_a, &GridLinesMgr::partThicknessChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const float )>(_a, &GridLinesMgr::pointSizeChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::azimuthalGridDisplayedChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::azimuthalGridColorChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorGridDisplayedChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::equatorGridColorChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::fixedEquatorGridDisplayedChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::fixedEquatorGridColorChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorJ2000GridDisplayedChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::equatorJ2000GridColorChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticGridDisplayedChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::eclipticGridColorChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticJ2000GridDisplayedChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::eclipticJ2000GridColorChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::galacticGridDisplayedChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::galacticGridColorChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::supergalacticGridDisplayedChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::supergalacticGridColorChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorLineDisplayedChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorPartsDisplayedChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorPartsLabeledChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::equatorLineColorChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorJ2000LineDisplayedChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorJ2000PartsDisplayedChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equatorJ2000PartsLabeledChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::equatorJ2000LineColorChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::fixedEquatorLineDisplayedChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::fixedEquatorPartsDisplayedChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::fixedEquatorPartsLabeledChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::fixedEquatorLineColorChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticLineDisplayedChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticPartsDisplayedChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticPartsLabeledChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticDatesLabeledChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::eclipticLineColorChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::invariablePlaneLineDisplayedChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::invariablePlaneLineColorChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::solarEquatorLineDisplayedChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::solarEquatorPartsDisplayedChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::solarEquatorPartsLabeledChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::solarEquatorLineColorChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticJ2000LineDisplayedChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticJ2000PartsDisplayedChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticJ2000PartsLabeledChanged, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::eclipticJ2000LineColorChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::precessionCirclesDisplayedChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::precessionPartsDisplayedChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::precessionPartsLabeledChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::precessionCirclesColorChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::meridianLineDisplayedChanged, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::meridianPartsDisplayedChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::meridianPartsLabeledChanged, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::meridianLineColorChanged, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::longitudeLineDisplayedChanged, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::longitudePartsDisplayedChanged, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::longitudePartsLabeledChanged, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::longitudeLineColorChanged, 58))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::quadratureLineDisplayedChanged, 59))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::quadratureLineColorChanged, 60))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::horizonLineDisplayedChanged, 61))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::horizonPartsDisplayedChanged, 62))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::horizonPartsLabeledChanged, 63))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::horizonLineColorChanged, 64))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::galacticEquatorLineDisplayedChanged, 65))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::galacticEquatorPartsDisplayedChanged, 66))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::galacticEquatorPartsLabeledChanged, 67))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::galacticEquatorLineColorChanged, 68))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::supergalacticEquatorLineDisplayedChanged, 69))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::supergalacticEquatorPartsDisplayedChanged, 70))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::supergalacticEquatorPartsLabeledChanged, 71))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::supergalacticEquatorLineColorChanged, 72))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::primeVerticalLineDisplayedChanged, 73))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::primeVerticalPartsDisplayedChanged, 74))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::primeVerticalPartsLabeledChanged, 75))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::primeVerticalLineColorChanged, 76))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::currentVerticalLineDisplayedChanged, 77))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::currentVerticalPartsDisplayedChanged, 78))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::currentVerticalPartsLabeledChanged, 79))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::currentVerticalLineColorChanged, 80))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::colureLinesDisplayedChanged, 81))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::colurePartsDisplayedChanged, 82))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::colurePartsLabeledChanged, 83))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::colureLinesColorChanged, 84))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::circumpolarCirclesDisplayedChanged, 85))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::circumpolarCirclesColorChanged, 86))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::umbraCircleDisplayedChanged, 87))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::umbraCircleColorChanged, 88))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::penumbraCircleDisplayedChanged, 89))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::penumbraCircleColorChanged, 90))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::celestialJ2000PolesDisplayedChanged, 91))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::celestialJ2000PolesColorChanged, 92))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::celestialPolesDisplayedChanged, 93))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::celestialPolesColorChanged, 94))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::zenithNadirDisplayedChanged, 95))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::zenithNadirColorChanged, 96))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticJ2000PolesDisplayedChanged, 97))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::eclipticJ2000PolesColorChanged, 98))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::eclipticPolesDisplayedChanged, 99))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::eclipticPolesColorChanged, 100))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::galacticPolesDisplayedChanged, 101))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::galacticPolesColorChanged, 102))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::galacticCenterDisplayedChanged, 103))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::galacticCenterColorChanged, 104))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::supergalacticPolesDisplayedChanged, 105))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::supergalacticPolesColorChanged, 106))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equinoxJ2000PointsDisplayedChanged, 107))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::equinoxJ2000PointsColorChanged, 108))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::equinoxPointsDisplayedChanged, 109))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::equinoxPointsColorChanged, 110))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::solsticeJ2000PointsDisplayedChanged, 111))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::solsticeJ2000PointsColorChanged, 112))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::solsticePointsDisplayedChanged, 113))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::solsticePointsColorChanged, 114))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::antisolarPointDisplayedChanged, 115))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::antisolarPointColorChanged, 116))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::umbraCenterPointDisplayedChanged, 117))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const bool )>(_a, &GridLinesMgr::apexPointsDisplayedChanged, 118))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(const Vec3f & )>(_a, &GridLinesMgr::apexPointsColorChanged, 119))
            return;
        if (QtMocHelpers::indexOfMethod<void (GridLinesMgr::*)(double )>(_a, &GridLinesMgr::gridSpacingMultiplierChanged, 120))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 116:
        case 113:
        case 111:
        case 109:
        case 107:
        case 105:
        case 103:
        case 101:
        case 99:
        case 97:
        case 95:
        case 93:
        case 91:
        case 89:
        case 87:
        case 85:
        case 83:
        case 81:
        case 77:
        case 73:
        case 69:
        case 65:
        case 61:
        case 57:
        case 55:
        case 51:
        case 47:
        case 43:
        case 39:
        case 37:
        case 33:
        case 28:
        case 24:
        case 20:
        case 16:
        case 14:
        case 12:
        case 10:
        case 8:
        case 6:
        case 4:
        case 2:
            *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->getFlagGridlines(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlagAzimuthalGrid(); break;
        case 2: *reinterpret_cast<Vec3f*>(_v) = _t->getColorAzimuthalGrid(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorGrid(); break;
        case 4: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEquatorGrid(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->getFlagFixedEquatorGrid(); break;
        case 6: *reinterpret_cast<Vec3f*>(_v) = _t->getColorFixedEquatorGrid(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorJ2000Grid(); break;
        case 8: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEquatorJ2000Grid(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticJ2000Grid(); break;
        case 10: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEclipticJ2000Grid(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticGrid(); break;
        case 12: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEclipticGrid(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getFlagGalacticGrid(); break;
        case 14: *reinterpret_cast<Vec3f*>(_v) = _t->getColorGalacticGrid(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->getFlagSupergalacticGrid(); break;
        case 16: *reinterpret_cast<Vec3f*>(_v) = _t->getColorSupergalacticGrid(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorLine(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorParts(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorLabeled(); break;
        case 20: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEquatorLine(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorJ2000Line(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorJ2000Parts(); break;
        case 23: *reinterpret_cast<bool*>(_v) = _t->getFlagEquatorJ2000Labeled(); break;
        case 24: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEquatorJ2000Line(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->getFlagFixedEquatorLine(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->getFlagFixedEquatorParts(); break;
        case 27: *reinterpret_cast<bool*>(_v) = _t->getFlagFixedEquatorLabeled(); break;
        case 28: *reinterpret_cast<Vec3f*>(_v) = _t->getColorFixedEquatorLine(); break;
        case 29: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticLine(); break;
        case 30: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticParts(); break;
        case 31: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticLabeled(); break;
        case 32: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticDatesLabeled(); break;
        case 33: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEclipticLine(); break;
        case 34: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticJ2000Line(); break;
        case 35: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticJ2000Parts(); break;
        case 36: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticJ2000Labeled(); break;
        case 37: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEclipticJ2000Line(); break;
        case 38: *reinterpret_cast<bool*>(_v) = _t->getFlagInvariablePlaneLine(); break;
        case 39: *reinterpret_cast<Vec3f*>(_v) = _t->getColorInvariablePlaneLine(); break;
        case 40: *reinterpret_cast<bool*>(_v) = _t->getFlagSolarEquatorLine(); break;
        case 41: *reinterpret_cast<bool*>(_v) = _t->getFlagSolarEquatorParts(); break;
        case 42: *reinterpret_cast<bool*>(_v) = _t->getFlagSolarEquatorLabeled(); break;
        case 43: *reinterpret_cast<Vec3f*>(_v) = _t->getColorSolarEquatorLine(); break;
        case 44: *reinterpret_cast<bool*>(_v) = _t->getFlagPrecessionCircles(); break;
        case 45: *reinterpret_cast<bool*>(_v) = _t->getFlagPrecessionParts(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->getFlagPrecessionLabeled(); break;
        case 47: *reinterpret_cast<Vec3f*>(_v) = _t->getColorPrecessionCircles(); break;
        case 48: *reinterpret_cast<bool*>(_v) = _t->getFlagMeridianLine(); break;
        case 49: *reinterpret_cast<bool*>(_v) = _t->getFlagMeridianParts(); break;
        case 50: *reinterpret_cast<bool*>(_v) = _t->getFlagMeridianLabeled(); break;
        case 51: *reinterpret_cast<Vec3f*>(_v) = _t->getColorMeridianLine(); break;
        case 52: *reinterpret_cast<bool*>(_v) = _t->getFlagLongitudeLine(); break;
        case 53: *reinterpret_cast<bool*>(_v) = _t->getFlagLongitudeParts(); break;
        case 54: *reinterpret_cast<bool*>(_v) = _t->getFlagLongitudeLabeled(); break;
        case 55: *reinterpret_cast<Vec3f*>(_v) = _t->getColorLongitudeLine(); break;
        case 56: *reinterpret_cast<bool*>(_v) = _t->getFlagQuadratureLine(); break;
        case 57: *reinterpret_cast<Vec3f*>(_v) = _t->getColorQuadratureLine(); break;
        case 58: *reinterpret_cast<bool*>(_v) = _t->getFlagHorizonLine(); break;
        case 59: *reinterpret_cast<bool*>(_v) = _t->getFlagHorizonParts(); break;
        case 60: *reinterpret_cast<bool*>(_v) = _t->getFlagHorizonLabeled(); break;
        case 61: *reinterpret_cast<Vec3f*>(_v) = _t->getColorHorizonLine(); break;
        case 62: *reinterpret_cast<bool*>(_v) = _t->getFlagGalacticEquatorLine(); break;
        case 63: *reinterpret_cast<bool*>(_v) = _t->getFlagGalacticEquatorParts(); break;
        case 64: *reinterpret_cast<bool*>(_v) = _t->getFlagGalacticEquatorLabeled(); break;
        case 65: *reinterpret_cast<Vec3f*>(_v) = _t->getColorGalacticEquatorLine(); break;
        case 66: *reinterpret_cast<bool*>(_v) = _t->getFlagSupergalacticEquatorLine(); break;
        case 67: *reinterpret_cast<bool*>(_v) = _t->getFlagSupergalacticEquatorParts(); break;
        case 68: *reinterpret_cast<bool*>(_v) = _t->getFlagSupergalacticEquatorLabeled(); break;
        case 69: *reinterpret_cast<Vec3f*>(_v) = _t->getColorSupergalacticEquatorLine(); break;
        case 70: *reinterpret_cast<bool*>(_v) = _t->getFlagPrimeVerticalLine(); break;
        case 71: *reinterpret_cast<bool*>(_v) = _t->getFlagPrimeVerticalParts(); break;
        case 72: *reinterpret_cast<bool*>(_v) = _t->getFlagPrimeVerticalLabeled(); break;
        case 73: *reinterpret_cast<Vec3f*>(_v) = _t->getColorPrimeVerticalLine(); break;
        case 74: *reinterpret_cast<bool*>(_v) = _t->getFlagCurrentVerticalLine(); break;
        case 75: *reinterpret_cast<bool*>(_v) = _t->getFlagCurrentVerticalParts(); break;
        case 76: *reinterpret_cast<bool*>(_v) = _t->getFlagCurrentVerticalLabeled(); break;
        case 77: *reinterpret_cast<Vec3f*>(_v) = _t->getColorCurrentVerticalLine(); break;
        case 78: *reinterpret_cast<bool*>(_v) = _t->getFlagColureLines(); break;
        case 79: *reinterpret_cast<bool*>(_v) = _t->getFlagColureParts(); break;
        case 80: *reinterpret_cast<bool*>(_v) = _t->getFlagColureLabeled(); break;
        case 81: *reinterpret_cast<Vec3f*>(_v) = _t->getColorColureLines(); break;
        case 82: *reinterpret_cast<bool*>(_v) = _t->getFlagCircumpolarCircles(); break;
        case 83: *reinterpret_cast<Vec3f*>(_v) = _t->getColorCircumpolarCircles(); break;
        case 84: *reinterpret_cast<bool*>(_v) = _t->getFlagUmbraCircle(); break;
        case 85: *reinterpret_cast<Vec3f*>(_v) = _t->getColorUmbraCircle(); break;
        case 86: *reinterpret_cast<bool*>(_v) = _t->getFlagPenumbraCircle(); break;
        case 87: *reinterpret_cast<Vec3f*>(_v) = _t->getColorPenumbraCircle(); break;
        case 88: *reinterpret_cast<bool*>(_v) = _t->getFlagCelestialJ2000Poles(); break;
        case 89: *reinterpret_cast<Vec3f*>(_v) = _t->getColorCelestialJ2000Poles(); break;
        case 90: *reinterpret_cast<bool*>(_v) = _t->getFlagCelestialPoles(); break;
        case 91: *reinterpret_cast<Vec3f*>(_v) = _t->getColorCelestialPoles(); break;
        case 92: *reinterpret_cast<bool*>(_v) = _t->getFlagZenithNadir(); break;
        case 93: *reinterpret_cast<Vec3f*>(_v) = _t->getColorZenithNadir(); break;
        case 94: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticJ2000Poles(); break;
        case 95: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEclipticJ2000Poles(); break;
        case 96: *reinterpret_cast<bool*>(_v) = _t->getFlagEclipticPoles(); break;
        case 97: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEclipticPoles(); break;
        case 98: *reinterpret_cast<bool*>(_v) = _t->getFlagGalacticPoles(); break;
        case 99: *reinterpret_cast<Vec3f*>(_v) = _t->getColorGalacticPoles(); break;
        case 100: *reinterpret_cast<bool*>(_v) = _t->getFlagGalacticCenter(); break;
        case 101: *reinterpret_cast<Vec3f*>(_v) = _t->getColorGalacticCenter(); break;
        case 102: *reinterpret_cast<bool*>(_v) = _t->getFlagSupergalacticPoles(); break;
        case 103: *reinterpret_cast<Vec3f*>(_v) = _t->getColorSupergalacticPoles(); break;
        case 104: *reinterpret_cast<bool*>(_v) = _t->getFlagEquinoxJ2000Points(); break;
        case 105: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEquinoxJ2000Points(); break;
        case 106: *reinterpret_cast<bool*>(_v) = _t->getFlagEquinoxPoints(); break;
        case 107: *reinterpret_cast<Vec3f*>(_v) = _t->getColorEquinoxPoints(); break;
        case 108: *reinterpret_cast<bool*>(_v) = _t->getFlagSolsticeJ2000Points(); break;
        case 109: *reinterpret_cast<Vec3f*>(_v) = _t->getColorSolsticeJ2000Points(); break;
        case 110: *reinterpret_cast<bool*>(_v) = _t->getFlagSolsticePoints(); break;
        case 111: *reinterpret_cast<Vec3f*>(_v) = _t->getColorSolsticePoints(); break;
        case 112: *reinterpret_cast<bool*>(_v) = _t->getFlagAntisolarPoint(); break;
        case 113: *reinterpret_cast<Vec3f*>(_v) = _t->getColorAntisolarPoint(); break;
        case 114: *reinterpret_cast<bool*>(_v) = _t->getFlagUmbraCenterPoint(); break;
        case 115: *reinterpret_cast<bool*>(_v) = _t->getFlagApexPoints(); break;
        case 116: *reinterpret_cast<Vec3f*>(_v) = _t->getColorApexPoints(); break;
        case 117: *reinterpret_cast<float*>(_v) = _t->getLineThickness(); break;
        case 118: *reinterpret_cast<float*>(_v) = _t->getPartThickness(); break;
        case 119: *reinterpret_cast<float*>(_v) = _t->getPointSize(); break;
        case 120: *reinterpret_cast<double*>(_v) = _t->getGridSpacingMultiplier(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagGridlines(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlagAzimuthalGrid(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setColorAzimuthalGrid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 3: _t->setFlagEquatorGrid(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setColorEquatorGrid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 5: _t->setFlagFixedEquatorGrid(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setColorFixedEquatorGrid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 7: _t->setFlagEquatorJ2000Grid(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setColorEquatorJ2000Grid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 9: _t->setFlagEclipticJ2000Grid(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setColorEclipticJ2000Grid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 11: _t->setFlagEclipticGrid(*reinterpret_cast<bool*>(_v)); break;
        case 12: _t->setColorEclipticGrid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 13: _t->setFlagGalacticGrid(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setColorGalacticGrid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 15: _t->setFlagSupergalacticGrid(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setColorSupergalacticGrid(*reinterpret_cast<Vec3f*>(_v)); break;
        case 17: _t->setFlagEquatorLine(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setFlagEquatorParts(*reinterpret_cast<bool*>(_v)); break;
        case 19: _t->setFlagEquatorLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setColorEquatorLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 21: _t->setFlagEquatorJ2000Line(*reinterpret_cast<bool*>(_v)); break;
        case 22: _t->setFlagEquatorJ2000Parts(*reinterpret_cast<bool*>(_v)); break;
        case 23: _t->setFlagEquatorJ2000Labeled(*reinterpret_cast<bool*>(_v)); break;
        case 24: _t->setColorEquatorJ2000Line(*reinterpret_cast<Vec3f*>(_v)); break;
        case 25: _t->setFlagFixedEquatorLine(*reinterpret_cast<bool*>(_v)); break;
        case 26: _t->setFlagFixedEquatorParts(*reinterpret_cast<bool*>(_v)); break;
        case 27: _t->setFlagFixedEquatorLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 28: _t->setColorFixedEquatorLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 29: _t->setFlagEclipticLine(*reinterpret_cast<bool*>(_v)); break;
        case 30: _t->setFlagEclipticParts(*reinterpret_cast<bool*>(_v)); break;
        case 31: _t->setFlagEclipticLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 32: _t->setFlagEclipticDatesLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 33: _t->setColorEclipticLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 34: _t->setFlagEclipticJ2000Line(*reinterpret_cast<bool*>(_v)); break;
        case 35: _t->setFlagEclipticJ2000Parts(*reinterpret_cast<bool*>(_v)); break;
        case 36: _t->setFlagEclipticJ2000Labeled(*reinterpret_cast<bool*>(_v)); break;
        case 37: _t->setColorEclipticJ2000Line(*reinterpret_cast<Vec3f*>(_v)); break;
        case 38: _t->setFlagInvariablePlaneLine(*reinterpret_cast<bool*>(_v)); break;
        case 39: _t->setColorInvariablePlaneLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 40: _t->setFlagSolarEquatorLine(*reinterpret_cast<bool*>(_v)); break;
        case 41: _t->setFlagSolarEquatorParts(*reinterpret_cast<bool*>(_v)); break;
        case 42: _t->setFlagSolarEquatorLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 43: _t->setColorSolarEquatorLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 44: _t->setFlagPrecessionCircles(*reinterpret_cast<bool*>(_v)); break;
        case 45: _t->setFlagPrecessionParts(*reinterpret_cast<bool*>(_v)); break;
        case 46: _t->setFlagPrecessionLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 47: _t->setColorPrecessionCircles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 48: _t->setFlagMeridianLine(*reinterpret_cast<bool*>(_v)); break;
        case 49: _t->setFlagMeridianParts(*reinterpret_cast<bool*>(_v)); break;
        case 50: _t->setFlagMeridianLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 51: _t->setColorMeridianLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 52: _t->setFlagLongitudeLine(*reinterpret_cast<bool*>(_v)); break;
        case 53: _t->setFlagLongitudeParts(*reinterpret_cast<bool*>(_v)); break;
        case 54: _t->setFlagLongitudeLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 55: _t->setColorLongitudeLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 56: _t->setFlagQuadratureLine(*reinterpret_cast<bool*>(_v)); break;
        case 57: _t->setColorQuadratureLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 58: _t->setFlagHorizonLine(*reinterpret_cast<bool*>(_v)); break;
        case 59: _t->setFlagHorizonParts(*reinterpret_cast<bool*>(_v)); break;
        case 60: _t->setFlagHorizonLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 61: _t->setColorHorizonLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 62: _t->setFlagGalacticEquatorLine(*reinterpret_cast<bool*>(_v)); break;
        case 63: _t->setFlagGalacticEquatorParts(*reinterpret_cast<bool*>(_v)); break;
        case 64: _t->setFlagGalacticEquatorLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 65: _t->setColorGalacticEquatorLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 66: _t->setFlagSupergalacticEquatorLine(*reinterpret_cast<bool*>(_v)); break;
        case 67: _t->setFlagSupergalacticEquatorParts(*reinterpret_cast<bool*>(_v)); break;
        case 68: _t->setFlagSupergalacticEquatorLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 69: _t->setColorSupergalacticEquatorLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 70: _t->setFlagPrimeVerticalLine(*reinterpret_cast<bool*>(_v)); break;
        case 71: _t->setFlagPrimeVerticalParts(*reinterpret_cast<bool*>(_v)); break;
        case 72: _t->setFlagPrimeVerticalLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 73: _t->setColorPrimeVerticalLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 74: _t->setFlagCurrentVerticalLine(*reinterpret_cast<bool*>(_v)); break;
        case 75: _t->setFlagCurrentVerticalParts(*reinterpret_cast<bool*>(_v)); break;
        case 76: _t->setFlagCurrentVerticalLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 77: _t->setColorCurrentVerticalLine(*reinterpret_cast<Vec3f*>(_v)); break;
        case 78: _t->setFlagColureLines(*reinterpret_cast<bool*>(_v)); break;
        case 79: _t->setFlagColureParts(*reinterpret_cast<bool*>(_v)); break;
        case 80: _t->setFlagColureLabeled(*reinterpret_cast<bool*>(_v)); break;
        case 81: _t->setColorColureLines(*reinterpret_cast<Vec3f*>(_v)); break;
        case 82: _t->setFlagCircumpolarCircles(*reinterpret_cast<bool*>(_v)); break;
        case 83: _t->setColorCircumpolarCircles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 84: _t->setFlagUmbraCircle(*reinterpret_cast<bool*>(_v)); break;
        case 85: _t->setColorUmbraCircle(*reinterpret_cast<Vec3f*>(_v)); break;
        case 86: _t->setFlagPenumbraCircle(*reinterpret_cast<bool*>(_v)); break;
        case 87: _t->setColorPenumbraCircle(*reinterpret_cast<Vec3f*>(_v)); break;
        case 88: _t->setFlagCelestialJ2000Poles(*reinterpret_cast<bool*>(_v)); break;
        case 89: _t->setColorCelestialJ2000Poles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 90: _t->setFlagCelestialPoles(*reinterpret_cast<bool*>(_v)); break;
        case 91: _t->setColorCelestialPoles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 92: _t->setFlagZenithNadir(*reinterpret_cast<bool*>(_v)); break;
        case 93: _t->setColorZenithNadir(*reinterpret_cast<Vec3f*>(_v)); break;
        case 94: _t->setFlagEclipticJ2000Poles(*reinterpret_cast<bool*>(_v)); break;
        case 95: _t->setColorEclipticJ2000Poles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 96: _t->setFlagEclipticPoles(*reinterpret_cast<bool*>(_v)); break;
        case 97: _t->setColorEclipticPoles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 98: _t->setFlagGalacticPoles(*reinterpret_cast<bool*>(_v)); break;
        case 99: _t->setColorGalacticPoles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 100: _t->setFlagGalacticCenter(*reinterpret_cast<bool*>(_v)); break;
        case 101: _t->setColorGalacticCenter(*reinterpret_cast<Vec3f*>(_v)); break;
        case 102: _t->setFlagSupergalacticPoles(*reinterpret_cast<bool*>(_v)); break;
        case 103: _t->setColorSupergalacticPoles(*reinterpret_cast<Vec3f*>(_v)); break;
        case 104: _t->setFlagEquinoxJ2000Points(*reinterpret_cast<bool*>(_v)); break;
        case 105: _t->setColorEquinoxJ2000Points(*reinterpret_cast<Vec3f*>(_v)); break;
        case 106: _t->setFlagEquinoxPoints(*reinterpret_cast<bool*>(_v)); break;
        case 107: _t->setColorEquinoxPoints(*reinterpret_cast<Vec3f*>(_v)); break;
        case 108: _t->setFlagSolsticeJ2000Points(*reinterpret_cast<bool*>(_v)); break;
        case 109: _t->setColorSolsticeJ2000Points(*reinterpret_cast<Vec3f*>(_v)); break;
        case 110: _t->setFlagSolsticePoints(*reinterpret_cast<bool*>(_v)); break;
        case 111: _t->setColorSolsticePoints(*reinterpret_cast<Vec3f*>(_v)); break;
        case 112: _t->setFlagAntisolarPoint(*reinterpret_cast<bool*>(_v)); break;
        case 113: _t->setColorAntisolarPoint(*reinterpret_cast<Vec3f*>(_v)); break;
        case 114: _t->setFlagUmbraCenterPoint(*reinterpret_cast<bool*>(_v)); break;
        case 115: _t->setFlagApexPoints(*reinterpret_cast<bool*>(_v)); break;
        case 116: _t->setColorApexPoints(*reinterpret_cast<Vec3f*>(_v)); break;
        case 117: _t->setLineThickness(*reinterpret_cast<float*>(_v)); break;
        case 118: _t->setPartThickness(*reinterpret_cast<float*>(_v)); break;
        case 119: _t->setPointSize(*reinterpret_cast<float*>(_v)); break;
        case 120: _t->setGridSpacingMultiplier(*reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

// SIGNAL 1
void GridLinesMgr::lineThicknessChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void GridLinesMgr::partThicknessChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void GridLinesMgr::pointSizeChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

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

// SIGNAL 5
void GridLinesMgr::azimuthalGridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

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

// SIGNAL 7
void GridLinesMgr::equatorGridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

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

// SIGNAL 9
void GridLinesMgr::fixedEquatorGridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

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

// SIGNAL 11
void GridLinesMgr::equatorJ2000GridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

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

// SIGNAL 13
void GridLinesMgr::eclipticGridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

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

// SIGNAL 15
void GridLinesMgr::eclipticJ2000GridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

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

// SIGNAL 17
void GridLinesMgr::galacticGridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

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

// SIGNAL 19
void GridLinesMgr::supergalacticGridColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

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

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

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

// SIGNAL 23
void GridLinesMgr::equatorLineColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void GridLinesMgr::equatorJ2000LineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

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

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

// SIGNAL 27
void GridLinesMgr::equatorJ2000LineColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

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

// SIGNAL 29
void GridLinesMgr::fixedEquatorPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

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

// SIGNAL 31
void GridLinesMgr::fixedEquatorLineColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

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

// SIGNAL 33
void GridLinesMgr::eclipticPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void GridLinesMgr::eclipticPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

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

// SIGNAL 36
void GridLinesMgr::eclipticLineColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

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

// SIGNAL 38
void GridLinesMgr::invariablePlaneLineColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

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

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

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

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

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

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

// SIGNAL 45
void GridLinesMgr::eclipticJ2000PartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 45, nullptr, _t1);
}

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

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

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

// SIGNAL 49
void GridLinesMgr::precessionPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 49, nullptr, _t1);
}

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

// SIGNAL 51
void GridLinesMgr::meridianLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 51, nullptr, _t1);
}

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

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

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

// SIGNAL 55
void GridLinesMgr::longitudeLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 55, nullptr, _t1);
}

// SIGNAL 56
void GridLinesMgr::longitudePartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 56, nullptr, _t1);
}

// SIGNAL 57
void GridLinesMgr::longitudePartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 57, nullptr, _t1);
}

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

// SIGNAL 59
void GridLinesMgr::quadratureLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 59, nullptr, _t1);
}

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

// SIGNAL 61
void GridLinesMgr::horizonLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 61, nullptr, _t1);
}

// SIGNAL 62
void GridLinesMgr::horizonPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 62, nullptr, _t1);
}

// SIGNAL 63
void GridLinesMgr::horizonPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 63, nullptr, _t1);
}

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

// SIGNAL 65
void GridLinesMgr::galacticEquatorLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 65, nullptr, _t1);
}

// SIGNAL 66
void GridLinesMgr::galacticEquatorPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 66, nullptr, _t1);
}

// SIGNAL 67
void GridLinesMgr::galacticEquatorPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 67, nullptr, _t1);
}

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

// SIGNAL 69
void GridLinesMgr::supergalacticEquatorLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 69, nullptr, _t1);
}

// SIGNAL 70
void GridLinesMgr::supergalacticEquatorPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 70, nullptr, _t1);
}

// SIGNAL 71
void GridLinesMgr::supergalacticEquatorPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 71, nullptr, _t1);
}

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

// SIGNAL 73
void GridLinesMgr::primeVerticalLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 73, nullptr, _t1);
}

// SIGNAL 74
void GridLinesMgr::primeVerticalPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 74, nullptr, _t1);
}

// SIGNAL 75
void GridLinesMgr::primeVerticalPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 75, nullptr, _t1);
}

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

// SIGNAL 77
void GridLinesMgr::currentVerticalLineDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 77, nullptr, _t1);
}

// SIGNAL 78
void GridLinesMgr::currentVerticalPartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 78, nullptr, _t1);
}

// SIGNAL 79
void GridLinesMgr::currentVerticalPartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 79, nullptr, _t1);
}

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

// SIGNAL 81
void GridLinesMgr::colureLinesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 81, nullptr, _t1);
}

// SIGNAL 82
void GridLinesMgr::colurePartsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 82, nullptr, _t1);
}

// SIGNAL 83
void GridLinesMgr::colurePartsLabeledChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 83, nullptr, _t1);
}

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

// SIGNAL 85
void GridLinesMgr::circumpolarCirclesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 85, nullptr, _t1);
}

// SIGNAL 86
void GridLinesMgr::circumpolarCirclesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 86, nullptr, _t1);
}

// SIGNAL 87
void GridLinesMgr::umbraCircleDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 87, nullptr, _t1);
}

// SIGNAL 88
void GridLinesMgr::umbraCircleColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 88, nullptr, _t1);
}

// SIGNAL 89
void GridLinesMgr::penumbraCircleDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 89, nullptr, _t1);
}

// SIGNAL 90
void GridLinesMgr::penumbraCircleColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 90, nullptr, _t1);
}

// SIGNAL 91
void GridLinesMgr::celestialJ2000PolesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 91, nullptr, _t1);
}

// SIGNAL 92
void GridLinesMgr::celestialJ2000PolesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 92, nullptr, _t1);
}

// SIGNAL 93
void GridLinesMgr::celestialPolesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 93, nullptr, _t1);
}

// SIGNAL 94
void GridLinesMgr::celestialPolesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 94, nullptr, _t1);
}

// SIGNAL 95
void GridLinesMgr::zenithNadirDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 95, nullptr, _t1);
}

// SIGNAL 96
void GridLinesMgr::zenithNadirColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 96, nullptr, _t1);
}

// SIGNAL 97
void GridLinesMgr::eclipticJ2000PolesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 97, nullptr, _t1);
}

// SIGNAL 98
void GridLinesMgr::eclipticJ2000PolesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 98, nullptr, _t1);
}

// SIGNAL 99
void GridLinesMgr::eclipticPolesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 99, nullptr, _t1);
}

// SIGNAL 100
void GridLinesMgr::eclipticPolesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 100, nullptr, _t1);
}

// SIGNAL 101
void GridLinesMgr::galacticPolesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 101, nullptr, _t1);
}

// SIGNAL 102
void GridLinesMgr::galacticPolesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 102, nullptr, _t1);
}

// SIGNAL 103
void GridLinesMgr::galacticCenterDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 103, nullptr, _t1);
}

// SIGNAL 104
void GridLinesMgr::galacticCenterColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 104, nullptr, _t1);
}

// SIGNAL 105
void GridLinesMgr::supergalacticPolesDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 105, nullptr, _t1);
}

// SIGNAL 106
void GridLinesMgr::supergalacticPolesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 106, nullptr, _t1);
}

// SIGNAL 107
void GridLinesMgr::equinoxJ2000PointsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 107, nullptr, _t1);
}

// SIGNAL 108
void GridLinesMgr::equinoxJ2000PointsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 108, nullptr, _t1);
}

// SIGNAL 109
void GridLinesMgr::equinoxPointsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 109, nullptr, _t1);
}

// SIGNAL 110
void GridLinesMgr::equinoxPointsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 110, nullptr, _t1);
}

// SIGNAL 111
void GridLinesMgr::solsticeJ2000PointsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 111, nullptr, _t1);
}

// SIGNAL 112
void GridLinesMgr::solsticeJ2000PointsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 112, nullptr, _t1);
}

// SIGNAL 113
void GridLinesMgr::solsticePointsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 113, nullptr, _t1);
}

// SIGNAL 114
void GridLinesMgr::solsticePointsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 114, nullptr, _t1);
}

// SIGNAL 115
void GridLinesMgr::antisolarPointDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 115, nullptr, _t1);
}

// SIGNAL 116
void GridLinesMgr::antisolarPointColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 116, nullptr, _t1);
}

// SIGNAL 117
void GridLinesMgr::umbraCenterPointDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 117, nullptr, _t1);
}

// SIGNAL 118
void GridLinesMgr::apexPointsDisplayedChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 118, nullptr, _t1);
}

// SIGNAL 119
void GridLinesMgr::apexPointsColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 119, nullptr, _t1);
}

// SIGNAL 120
void GridLinesMgr::gridSpacingMultiplierChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 120, nullptr, _t1);
}
QT_WARNING_POP
