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

template <> constexpr inline auto NebulaMgr::qt_create_metaobjectdata<qt_meta_tag_ZN9NebulaMgrE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NebulaMgr",
        "flagHintsDisplayedChanged",
        "",
        "b",
        "flagUseTypeFiltersChanged",
        "catalogFiltersChanged",
        "flags",
        "typeFiltersChanged",
        "hintsProportionalChanged",
        "flagOutlinesDisplayedChanged",
        "flagAdditionalNamesDisplayedChanged",
        "designationUsageChanged",
        "flagShowOnlyNamedDSOChanged",
        "flagSurfaceBrightnessUsageChanged",
        "flagSurfaceBrightnessArcsecUsageChanged",
        "flagSurfaceBrightnessShortNotationUsageChanged",
        "flagSizeLimitsUsageChanged",
        "minSizeLimitChanged",
        "s",
        "maxSizeLimitChanged",
        "labelsAmountChanged",
        "a",
        "hintsAmountChanged",
        "f",
        "labelsBrightnessChanged",
        "hintsBrightnessChanged",
        "labelsColorChanged",
        "Vec3f",
        "color",
        "circlesColorChanged",
        "regionsColorChanged",
        "galaxiesColorChanged",
        "activeGalaxiesColorChanged",
        "radioGalaxiesColorChanged",
        "interactingGalaxiesColorChanged",
        "quasarsColorChanged",
        "possibleQuasarsColorChanged",
        "clustersColorChanged",
        "openClustersColorChanged",
        "globularClustersColorChanged",
        "stellarAssociationsColorChanged",
        "starCloudsColorChanged",
        "starsColorChanged",
        "symbioticStarsColorChanged",
        "emissionLineStarsColorChanged",
        "nebulaeColorChanged",
        "planetaryNebulaeColorChanged",
        "darkNebulaeColorChanged",
        "reflectionNebulaeColorChanged",
        "bipolarNebulaeColorChanged",
        "emissionNebulaeColorChanged",
        "possiblePlanetaryNebulaeColorChanged",
        "protoplanetaryNebulaeColorChanged",
        "hydrogenRegionsColorChanged",
        "interstellarMatterColorChanged",
        "emissionObjectsColorChanged",
        "molecularCloudsColorChanged",
        "blLacObjectsColorChanged",
        "blazarsColorChanged",
        "youngStellarObjectsColorChanged",
        "supernovaRemnantsColorChanged",
        "supernovaCandidatesColorChanged",
        "supernovaRemnantCandidatesColorChanged",
        "galaxyClustersColorChanged",
        "setCatalogFilters",
        "cflags",
        "getCatalogFilters",
        "selectAllCatalogs",
        "selectStandardCatalogs",
        "selectNoneCatalogs",
        "loadCatalogFilters",
        "storeCatalogFilters",
        "setTypeFilters",
        "tflags",
        "getTypeFilters",
        "setCirclesColor",
        "c",
        "getCirclesColor",
        "setRegionsColor",
        "getRegionsColor",
        "setGalaxyColor",
        "getGalaxyColor",
        "setActiveGalaxyColor",
        "getActiveGalaxyColor",
        "setInteractingGalaxyColor",
        "getInteractingGalaxyColor",
        "setRadioGalaxyColor",
        "getRadioGalaxyColor",
        "setQuasarColor",
        "getQuasarColor",
        "setNebulaColor",
        "getNebulaColor",
        "setPlanetaryNebulaColor",
        "getPlanetaryNebulaColor",
        "setReflectionNebulaColor",
        "getReflectionNebulaColor",
        "setBipolarNebulaColor",
        "getBipolarNebulaColor",
        "setEmissionNebulaColor",
        "getEmissionNebulaColor",
        "setHydrogenRegionColor",
        "getHydrogenRegionColor",
        "setSupernovaRemnantColor",
        "getSupernovaRemnantColor",
        "setSupernovaCandidateColor",
        "getSupernovaCandidateColor",
        "setSupernovaRemnantCandidateColor",
        "getSupernovaRemnantCandidateColor",
        "setInterstellarMatterColor",
        "getInterstellarMatterColor",
        "setDarkNebulaColor",
        "getDarkNebulaColor",
        "setClusterColor",
        "getClusterColor",
        "setOpenClusterColor",
        "getOpenClusterColor",
        "setGlobularClusterColor",
        "getGlobularClusterColor",
        "setStellarAssociationColor",
        "getStellarAssociationColor",
        "setStarCloudColor",
        "getStarCloudColor",
        "setEmissionObjectColor",
        "getEmissionObjectColor",
        "setBlLacObjectColor",
        "getBlLacObjectColor",
        "setBlazarColor",
        "getBlazarColor",
        "setMolecularCloudColor",
        "getMolecularCloudColor",
        "setYoungStellarObjectColor",
        "getYoungStellarObjectColor",
        "setPossibleQuasarColor",
        "getPossibleQuasarColor",
        "setPossiblePlanetaryNebulaColor",
        "getPossiblePlanetaryNebulaColor",
        "setProtoplanetaryNebulaColor",
        "getProtoplanetaryNebulaColor",
        "setStarColor",
        "getStarColor",
        "setSymbioticStarColor",
        "getSymbioticStarColor",
        "setEmissionLineStarColor",
        "getEmissionLineStarColor",
        "setGalaxyClusterColor",
        "getGalaxyClusterColor",
        "setHintsFadeDuration",
        "duration",
        "setFlagHints",
        "getFlagHints",
        "setHintsProportional",
        "proportional",
        "getHintsProportional",
        "setFlagOutlines",
        "flag",
        "getFlagOutlines",
        "setFlagAdditionalNames",
        "getFlagAdditionalNames",
        "setDesignationUsage",
        "getDesignationUsage",
        "setFlagSurfaceBrightnessUsage",
        "usage",
        "getFlagSurfaceBrightnessUsage",
        "setFlagSurfaceBrightnessArcsecUsage",
        "getFlagSurfaceBrightnessArcsecUsage",
        "setFlagSurfaceBrightnessShortNotationUsage",
        "getFlagSurfaceBrightnessShortNotationUsage",
        "setFlagSizeLimitsUsage",
        "getFlagSizeLimitsUsage",
        "setFlagShow",
        "getFlagShow",
        "setFlagUseTypeFilters",
        "getFlagUseTypeFilters",
        "setFlagShowOnlyNamedDSO",
        "getFlagShowOnlyNamedDSO",
        "setMinSizeLimit",
        "getMinSizeLimit",
        "setMaxSizeLimit",
        "getMaxSizeLimit",
        "setLabelsColor",
        "getLabelsColor",
        "setLabelsAmount",
        "getLabelsAmount",
        "setHintsAmount",
        "getHintsAmount",
        "setLabelsBrightness",
        "getLabelsBrightness",
        "setHintsBrightness",
        "getHintsBrightness",
        "updateI18n",
        "updateSkyCulture",
        "StelSkyCulture",
        "skyCulture",
        "loadCultureSpecificNames",
        "QJsonObject",
        "data",
        "loadCultureSpecificNameForNamedObject",
        "QJsonArray",
        "commonName",
        "setFontSizeFromApp",
        "size",
        "flagHintDisplayed",
        "flagTypeFiltersUsage",
        "typeFilters",
        "catalogFilters",
        "hintsProportional",
        "flagOutlinesDisplayed",
        "flagAdditionalNamesDisplayed",
        "flagSurfaceBrightnessUsage",
        "flagSurfaceBrightnessArcsecUsage",
        "flagSurfaceBrightnessShortNotationUsage",
        "labelsAmount",
        "hintsAmount",
        "flagDesignationLabels",
        "flagShowOnlyNamedDSO",
        "flagUseSizeLimits",
        "minSizeLimit",
        "maxSizeLimit",
        "hintsBrightness",
        "labelsBrightness",
        "labelsColor",
        "circlesColor",
        "regionsColor",
        "galaxiesColor",
        "activeGalaxiesColor",
        "radioGalaxiesColor",
        "interactingGalaxiesColor",
        "quasarsColor",
        "possibleQuasarsColor",
        "clustersColor",
        "openClustersColor",
        "globularClustersColor",
        "stellarAssociationsColor",
        "starCloudsColor",
        "starsColor",
        "symbioticStarsColor",
        "emissionLineStarsColor",
        "nebulaeColor",
        "planetaryNebulaeColor",
        "darkNebulaeColor",
        "reflectionNebulaeColor",
        "bipolarNebulaeColor",
        "emissionNebulaeColor",
        "possiblePlanetaryNebulaeColor",
        "protoplanetaryNebulaeColor",
        "hydrogenRegionsColor",
        "interstellarMatterColor",
        "emissionObjectsColor",
        "molecularCloudsColor",
        "blLacObjectsColor",
        "blazarsColor",
        "youngStellarObjectsColor",
        "supernovaRemnantsColor",
        "supernovaCandidatesColor",
        "supernovaRemnantCandidatesColor",
        "galaxyClustersColor"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'flagHintsDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagUseTypeFiltersChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'catalogFiltersChanged'
        QtMocHelpers::SignalData<void(int)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Signal 'typeFiltersChanged'
        QtMocHelpers::SignalData<void(int)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 6 },
        }}),
        // Signal 'hintsProportionalChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagOutlinesDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagAdditionalNamesDisplayedChanged'
        QtMocHelpers::SignalData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'designationUsageChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagShowOnlyNamedDSOChanged'
        QtMocHelpers::SignalData<void(bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagSurfaceBrightnessUsageChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagSurfaceBrightnessArcsecUsageChanged'
        QtMocHelpers::SignalData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagSurfaceBrightnessShortNotationUsageChanged'
        QtMocHelpers::SignalData<void(bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'flagSizeLimitsUsageChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'minSizeLimitChanged'
        QtMocHelpers::SignalData<void(double)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 18 },
        }}),
        // Signal 'maxSizeLimitChanged'
        QtMocHelpers::SignalData<void(double)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 18 },
        }}),
        // Signal 'labelsAmountChanged'
        QtMocHelpers::SignalData<void(double)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 21 },
        }}),
        // Signal 'hintsAmountChanged'
        QtMocHelpers::SignalData<void(double)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 23 },
        }}),
        // Signal 'labelsBrightnessChanged'
        QtMocHelpers::SignalData<void(double)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Signal 'hintsBrightnessChanged'
        QtMocHelpers::SignalData<void(double)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Signal 'labelsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'circlesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'regionsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'galaxiesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'activeGalaxiesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'radioGalaxiesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'interactingGalaxiesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'quasarsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'possibleQuasarsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'clustersColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'openClustersColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'globularClustersColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'stellarAssociationsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'starCloudsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'starsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'symbioticStarsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'emissionLineStarsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'nebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'planetaryNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'darkNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'reflectionNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'bipolarNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'emissionNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'possiblePlanetaryNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'protoplanetaryNebulaeColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'hydrogenRegionsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'interstellarMatterColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'emissionObjectsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'molecularCloudsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'blLacObjectsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'blazarsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'youngStellarObjectsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'supernovaRemnantsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'supernovaCandidatesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'supernovaRemnantCandidatesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Signal 'galaxyClustersColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 28 },
        }}),
        // Slot 'setCatalogFilters'
        QtMocHelpers::SlotData<void(int)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 65 },
        }}),
        // Slot 'getCatalogFilters'
        QtMocHelpers::SlotData<int() const>(66, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'selectAllCatalogs'
        QtMocHelpers::SlotData<void()>(67, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectStandardCatalogs'
        QtMocHelpers::SlotData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectNoneCatalogs'
        QtMocHelpers::SlotData<void()>(69, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loadCatalogFilters'
        QtMocHelpers::SlotData<void()>(70, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'storeCatalogFilters'
        QtMocHelpers::SlotData<void()>(71, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setTypeFilters'
        QtMocHelpers::SlotData<void(int)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 73 },
        }}),
        // Slot 'getTypeFilters'
        QtMocHelpers::SlotData<int() const>(74, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setCirclesColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getCirclesColor'
        QtMocHelpers::SlotData<const Vec3f() const>(77, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setRegionsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getRegionsColor'
        QtMocHelpers::SlotData<const Vec3f() const>(79, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setGalaxyColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getGalaxyColor'
        QtMocHelpers::SlotData<const Vec3f() const>(81, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setActiveGalaxyColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getActiveGalaxyColor'
        QtMocHelpers::SlotData<const Vec3f() const>(83, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setInteractingGalaxyColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getInteractingGalaxyColor'
        QtMocHelpers::SlotData<const Vec3f() const>(85, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setRadioGalaxyColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getRadioGalaxyColor'
        QtMocHelpers::SlotData<const Vec3f() const>(87, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setQuasarColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getQuasarColor'
        QtMocHelpers::SlotData<const Vec3f() const>(89, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(91, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setPlanetaryNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getPlanetaryNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(93, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setReflectionNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getReflectionNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(95, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setBipolarNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getBipolarNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(97, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setEmissionNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getEmissionNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(99, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setHydrogenRegionColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getHydrogenRegionColor'
        QtMocHelpers::SlotData<const Vec3f() const>(101, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setSupernovaRemnantColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getSupernovaRemnantColor'
        QtMocHelpers::SlotData<const Vec3f() const>(103, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setSupernovaCandidateColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getSupernovaCandidateColor'
        QtMocHelpers::SlotData<const Vec3f() const>(105, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setSupernovaRemnantCandidateColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getSupernovaRemnantCandidateColor'
        QtMocHelpers::SlotData<const Vec3f() const>(107, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setInterstellarMatterColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getInterstellarMatterColor'
        QtMocHelpers::SlotData<const Vec3f() const>(109, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setDarkNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getDarkNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(111, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setClusterColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getClusterColor'
        QtMocHelpers::SlotData<const Vec3f() const>(113, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setOpenClusterColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getOpenClusterColor'
        QtMocHelpers::SlotData<const Vec3f() const>(115, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setGlobularClusterColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getGlobularClusterColor'
        QtMocHelpers::SlotData<const Vec3f() const>(117, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setStellarAssociationColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getStellarAssociationColor'
        QtMocHelpers::SlotData<const Vec3f() const>(119, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setStarCloudColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getStarCloudColor'
        QtMocHelpers::SlotData<const Vec3f() const>(121, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setEmissionObjectColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getEmissionObjectColor'
        QtMocHelpers::SlotData<const Vec3f() const>(123, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setBlLacObjectColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getBlLacObjectColor'
        QtMocHelpers::SlotData<const Vec3f() const>(125, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setBlazarColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(126, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getBlazarColor'
        QtMocHelpers::SlotData<const Vec3f() const>(127, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setMolecularCloudColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(128, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getMolecularCloudColor'
        QtMocHelpers::SlotData<const Vec3f() const>(129, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setYoungStellarObjectColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getYoungStellarObjectColor'
        QtMocHelpers::SlotData<const Vec3f() const>(131, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setPossibleQuasarColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getPossibleQuasarColor'
        QtMocHelpers::SlotData<const Vec3f() const>(133, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setPossiblePlanetaryNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getPossiblePlanetaryNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(135, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setProtoplanetaryNebulaColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getProtoplanetaryNebulaColor'
        QtMocHelpers::SlotData<const Vec3f() const>(137, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setStarColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getStarColor'
        QtMocHelpers::SlotData<const Vec3f() const>(139, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setSymbioticStarColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getSymbioticStarColor'
        QtMocHelpers::SlotData<const Vec3f() const>(141, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setEmissionLineStarColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getEmissionLineStarColor'
        QtMocHelpers::SlotData<const Vec3f() const>(143, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setGalaxyClusterColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(144, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getGalaxyClusterColor'
        QtMocHelpers::SlotData<const Vec3f() const>(145, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setHintsFadeDuration'
        QtMocHelpers::SlotData<void(float)>(146, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 147 },
        }}),
        // Slot 'setFlagHints'
        QtMocHelpers::SlotData<void(bool)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagHints'
        QtMocHelpers::SlotData<bool() const>(149, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setHintsProportional'
        QtMocHelpers::SlotData<void(const bool)>(150, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 151 },
        }}),
        // Slot 'getHintsProportional'
        QtMocHelpers::SlotData<bool() const>(152, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagOutlines'
        QtMocHelpers::SlotData<void(const bool)>(153, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getFlagOutlines'
        QtMocHelpers::SlotData<bool() const>(155, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAdditionalNames'
        QtMocHelpers::SlotData<void(const bool)>(156, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getFlagAdditionalNames'
        QtMocHelpers::SlotData<bool() const>(157, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setDesignationUsage'
        QtMocHelpers::SlotData<void(const bool)>(158, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getDesignationUsage'
        QtMocHelpers::SlotData<bool() const>(159, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSurfaceBrightnessUsage'
        QtMocHelpers::SlotData<void(const bool)>(160, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 161 },
        }}),
        // Slot 'getFlagSurfaceBrightnessUsage'
        QtMocHelpers::SlotData<bool() const>(162, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSurfaceBrightnessArcsecUsage'
        QtMocHelpers::SlotData<void(const bool)>(163, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 161 },
        }}),
        // Slot 'getFlagSurfaceBrightnessArcsecUsage'
        QtMocHelpers::SlotData<bool() const>(164, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSurfaceBrightnessShortNotationUsage'
        QtMocHelpers::SlotData<void(const bool)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 161 },
        }}),
        // Slot 'getFlagSurfaceBrightnessShortNotationUsage'
        QtMocHelpers::SlotData<bool() const>(166, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagSizeLimitsUsage'
        QtMocHelpers::SlotData<void(const bool)>(167, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 161 },
        }}),
        // Slot 'getFlagSizeLimitsUsage'
        QtMocHelpers::SlotData<bool() const>(168, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagShow'
        QtMocHelpers::SlotData<void(bool)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagShow'
        QtMocHelpers::SlotData<bool() const>(170, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagUseTypeFilters'
        QtMocHelpers::SlotData<void(const bool)>(171, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagUseTypeFilters'
        QtMocHelpers::SlotData<bool() const>(172, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagShowOnlyNamedDSO'
        QtMocHelpers::SlotData<void(const bool)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagShowOnlyNamedDSO'
        QtMocHelpers::SlotData<bool() const>(174, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setMinSizeLimit'
        QtMocHelpers::SlotData<void(double)>(175, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 18 },
        }}),
        // Slot 'getMinSizeLimit'
        QtMocHelpers::SlotData<double() const>(176, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setMaxSizeLimit'
        QtMocHelpers::SlotData<void(double)>(177, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 18 },
        }}),
        // Slot 'getMaxSizeLimit'
        QtMocHelpers::SlotData<double() const>(178, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setLabelsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(179, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 27, 76 },
        }}),
        // Slot 'getLabelsColor'
        QtMocHelpers::SlotData<const Vec3f() const>(180, 2, QMC::AccessPublic, 0x80000000 | 27),
        // Slot 'setLabelsAmount'
        QtMocHelpers::SlotData<void(double)>(181, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 21 },
        }}),
        // Slot 'getLabelsAmount'
        QtMocHelpers::SlotData<double() const>(182, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setHintsAmount'
        QtMocHelpers::SlotData<void(double)>(183, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 23 },
        }}),
        // Slot 'getHintsAmount'
        QtMocHelpers::SlotData<double() const>(184, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setLabelsBrightness'
        QtMocHelpers::SlotData<void(double)>(185, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Slot 'getLabelsBrightness'
        QtMocHelpers::SlotData<double() const>(186, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setHintsBrightness'
        QtMocHelpers::SlotData<void(double)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 3 },
        }}),
        // Slot 'getHintsBrightness'
        QtMocHelpers::SlotData<double() const>(188, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'updateI18n'
        QtMocHelpers::SlotData<void()>(189, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateSkyCulture'
        QtMocHelpers::SlotData<void(const StelSkyCulture &)>(190, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 191, 192 },
        }}),
        // Slot 'loadCultureSpecificNames'
        QtMocHelpers::SlotData<int(const QJsonObject &)>(193, 2, QMC::AccessPrivate, QMetaType::Int, {{
            { 0x80000000 | 194, 195 },
        }}),
        // Slot 'loadCultureSpecificNameForNamedObject'
        QtMocHelpers::SlotData<void(const QJsonArray &, const QString &)>(196, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 197, 195 }, { QMetaType::QString, 198 },
        }}),
        // Slot 'setFontSizeFromApp'
        QtMocHelpers::SlotData<void(int)>(199, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 200 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'flagHintDisplayed'
        QtMocHelpers::PropertyData<bool>(201, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'flagTypeFiltersUsage'
        QtMocHelpers::PropertyData<bool>(202, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 1),
        // property 'typeFilters'
        QtMocHelpers::PropertyData<int>(203, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'catalogFilters'
        QtMocHelpers::PropertyData<int>(204, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'hintsProportional'
        QtMocHelpers::PropertyData<bool>(205, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'flagOutlinesDisplayed'
        QtMocHelpers::PropertyData<bool>(206, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 5),
        // property 'flagAdditionalNamesDisplayed'
        QtMocHelpers::PropertyData<bool>(207, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 6),
        // property 'flagSurfaceBrightnessUsage'
        QtMocHelpers::PropertyData<bool>(208, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'flagSurfaceBrightnessArcsecUsage'
        QtMocHelpers::PropertyData<bool>(209, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'flagSurfaceBrightnessShortNotationUsage'
        QtMocHelpers::PropertyData<bool>(210, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'labelsAmount'
        QtMocHelpers::PropertyData<double>(211, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'hintsAmount'
        QtMocHelpers::PropertyData<double>(212, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'flagDesignationLabels'
        QtMocHelpers::PropertyData<bool>(213, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 7),
        // property 'flagShowOnlyNamedDSO'
        QtMocHelpers::PropertyData<bool>(214, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'flagUseSizeLimits'
        QtMocHelpers::PropertyData<bool>(215, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'minSizeLimit'
        QtMocHelpers::PropertyData<double>(216, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'maxSizeLimit'
        QtMocHelpers::PropertyData<double>(217, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'hintsBrightness'
        QtMocHelpers::PropertyData<double>(218, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'labelsBrightness'
        QtMocHelpers::PropertyData<double>(219, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'labelsColor'
        QtMocHelpers::PropertyData<Vec3f>(220, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 19),
        // property 'circlesColor'
        QtMocHelpers::PropertyData<Vec3f>(221, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 20),
        // property 'regionsColor'
        QtMocHelpers::PropertyData<Vec3f>(222, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 21),
        // property 'galaxiesColor'
        QtMocHelpers::PropertyData<Vec3f>(223, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 22),
        // property 'activeGalaxiesColor'
        QtMocHelpers::PropertyData<Vec3f>(224, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 23),
        // property 'radioGalaxiesColor'
        QtMocHelpers::PropertyData<Vec3f>(225, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 24),
        // property 'interactingGalaxiesColor'
        QtMocHelpers::PropertyData<Vec3f>(226, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 25),
        // property 'quasarsColor'
        QtMocHelpers::PropertyData<Vec3f>(227, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 26),
        // property 'possibleQuasarsColor'
        QtMocHelpers::PropertyData<Vec3f>(228, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 27),
        // property 'clustersColor'
        QtMocHelpers::PropertyData<Vec3f>(229, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 28),
        // property 'openClustersColor'
        QtMocHelpers::PropertyData<Vec3f>(230, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 29),
        // property 'globularClustersColor'
        QtMocHelpers::PropertyData<Vec3f>(231, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 30),
        // property 'stellarAssociationsColor'
        QtMocHelpers::PropertyData<Vec3f>(232, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 31),
        // property 'starCloudsColor'
        QtMocHelpers::PropertyData<Vec3f>(233, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 32),
        // property 'starsColor'
        QtMocHelpers::PropertyData<Vec3f>(234, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 33),
        // property 'symbioticStarsColor'
        QtMocHelpers::PropertyData<Vec3f>(235, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 34),
        // property 'emissionLineStarsColor'
        QtMocHelpers::PropertyData<Vec3f>(236, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 35),
        // property 'nebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(237, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 36),
        // property 'planetaryNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(238, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 37),
        // property 'darkNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(239, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 38),
        // property 'reflectionNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(240, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 39),
        // property 'bipolarNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(241, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 40),
        // property 'emissionNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(242, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 41),
        // property 'possiblePlanetaryNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(243, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 42),
        // property 'protoplanetaryNebulaeColor'
        QtMocHelpers::PropertyData<Vec3f>(244, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 43),
        // property 'hydrogenRegionsColor'
        QtMocHelpers::PropertyData<Vec3f>(245, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 44),
        // property 'interstellarMatterColor'
        QtMocHelpers::PropertyData<Vec3f>(246, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 45),
        // property 'emissionObjectsColor'
        QtMocHelpers::PropertyData<Vec3f>(247, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 46),
        // property 'molecularCloudsColor'
        QtMocHelpers::PropertyData<Vec3f>(248, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 47),
        // property 'blLacObjectsColor'
        QtMocHelpers::PropertyData<Vec3f>(249, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 48),
        // property 'blazarsColor'
        QtMocHelpers::PropertyData<Vec3f>(250, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 49),
        // property 'youngStellarObjectsColor'
        QtMocHelpers::PropertyData<Vec3f>(251, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 50),
        // property 'supernovaRemnantsColor'
        QtMocHelpers::PropertyData<Vec3f>(252, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 51),
        // property 'supernovaCandidatesColor'
        QtMocHelpers::PropertyData<Vec3f>(253, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 52),
        // property 'supernovaRemnantCandidatesColor'
        QtMocHelpers::PropertyData<Vec3f>(254, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 53),
        // property 'galaxyClustersColor'
        QtMocHelpers::PropertyData<Vec3f>(255, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 54),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<NebulaMgr, qt_meta_tag_ZN9NebulaMgrE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject NebulaMgr::staticMetaObject = { {
    QMetaObject::SuperData::link<StelObjectModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9NebulaMgrE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9NebulaMgrE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9NebulaMgrE_t>.metaTypes,
    nullptr
} };

void NebulaMgr::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<NebulaMgr *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->flagHintsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->flagUseTypeFiltersChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->catalogFiltersChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 3: _t->typeFiltersChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 4: _t->hintsProportionalChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->flagOutlinesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->flagAdditionalNamesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->designationUsageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->flagShowOnlyNamedDSOChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->flagSurfaceBrightnessUsageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->flagSurfaceBrightnessArcsecUsageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->flagSurfaceBrightnessShortNotationUsageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->flagSizeLimitsUsageChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->minSizeLimitChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 14: _t->maxSizeLimitChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 15: _t->labelsAmountChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 16: _t->hintsAmountChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 17: _t->labelsBrightnessChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 18: _t->hintsBrightnessChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 19: _t->labelsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 20: _t->circlesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 21: _t->regionsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 22: _t->galaxiesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 23: _t->activeGalaxiesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 24: _t->radioGalaxiesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 25: _t->interactingGalaxiesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 26: _t->quasarsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 27: _t->possibleQuasarsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 28: _t->clustersColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 29: _t->openClustersColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 30: _t->globularClustersColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 31: _t->stellarAssociationsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 32: _t->starCloudsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 33: _t->starsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 34: _t->symbioticStarsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 35: _t->emissionLineStarsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 36: _t->nebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 37: _t->planetaryNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 38: _t->darkNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 39: _t->reflectionNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 40: _t->bipolarNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 41: _t->emissionNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 42: _t->possiblePlanetaryNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 43: _t->protoplanetaryNebulaeColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 44: _t->hydrogenRegionsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 45: _t->interstellarMatterColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 46: _t->emissionObjectsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 47: _t->molecularCloudsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 48: _t->blLacObjectsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 49: _t->blazarsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 50: _t->youngStellarObjectsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 51: _t->supernovaRemnantsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 52: _t->supernovaCandidatesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 53: _t->supernovaRemnantCandidatesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 54: _t->galaxyClustersColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 55: _t->setCatalogFilters((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 56: { int _r = _t->getCatalogFilters();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->selectAllCatalogs(); break;
        case 58: _t->selectStandardCatalogs(); break;
        case 59: _t->selectNoneCatalogs(); break;
        case 60: _t->loadCatalogFilters(); break;
        case 61: _t->storeCatalogFilters(); break;
        case 62: _t->setTypeFilters((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 63: { int _r = _t->getTypeFilters();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 64: _t->setCirclesColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 65: { Vec3f _r = _t->getCirclesColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 66: _t->setRegionsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 67: { Vec3f _r = _t->getRegionsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 68: _t->setGalaxyColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 69: { Vec3f _r = _t->getGalaxyColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 70: _t->setActiveGalaxyColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 71: { Vec3f _r = _t->getActiveGalaxyColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 72: _t->setInteractingGalaxyColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 73: { Vec3f _r = _t->getInteractingGalaxyColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 74: _t->setRadioGalaxyColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 75: { Vec3f _r = _t->getRadioGalaxyColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 76: _t->setQuasarColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 77: { Vec3f _r = _t->getQuasarColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 78: _t->setNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 79: { Vec3f _r = _t->getNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 80: _t->setPlanetaryNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 81: { Vec3f _r = _t->getPlanetaryNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 82: _t->setReflectionNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 83: { Vec3f _r = _t->getReflectionNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 84: _t->setBipolarNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 85: { Vec3f _r = _t->getBipolarNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 86: _t->setEmissionNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 87: { Vec3f _r = _t->getEmissionNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 88: _t->setHydrogenRegionColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 89: { Vec3f _r = _t->getHydrogenRegionColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 90: _t->setSupernovaRemnantColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 91: { Vec3f _r = _t->getSupernovaRemnantColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 92: _t->setSupernovaCandidateColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 93: { Vec3f _r = _t->getSupernovaCandidateColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 94: _t->setSupernovaRemnantCandidateColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 95: { Vec3f _r = _t->getSupernovaRemnantCandidateColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 96: _t->setInterstellarMatterColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 97: { Vec3f _r = _t->getInterstellarMatterColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 98: _t->setDarkNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 99: { Vec3f _r = _t->getDarkNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 100: _t->setClusterColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 101: { Vec3f _r = _t->getClusterColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 102: _t->setOpenClusterColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 103: { Vec3f _r = _t->getOpenClusterColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 104: _t->setGlobularClusterColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 105: { Vec3f _r = _t->getGlobularClusterColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 106: _t->setStellarAssociationColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 107: { Vec3f _r = _t->getStellarAssociationColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 108: _t->setStarCloudColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 109: { Vec3f _r = _t->getStarCloudColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 110: _t->setEmissionObjectColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 111: { Vec3f _r = _t->getEmissionObjectColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 112: _t->setBlLacObjectColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 113: { Vec3f _r = _t->getBlLacObjectColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 114: _t->setBlazarColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 115: { Vec3f _r = _t->getBlazarColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 116: _t->setMolecularCloudColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 117: { Vec3f _r = _t->getMolecularCloudColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 118: _t->setYoungStellarObjectColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 119: { Vec3f _r = _t->getYoungStellarObjectColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 120: _t->setPossibleQuasarColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 121: { Vec3f _r = _t->getPossibleQuasarColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 122: _t->setPossiblePlanetaryNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 123: { Vec3f _r = _t->getPossiblePlanetaryNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 124: _t->setProtoplanetaryNebulaColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 125: { Vec3f _r = _t->getProtoplanetaryNebulaColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 126: _t->setStarColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 127: { Vec3f _r = _t->getStarColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 128: _t->setSymbioticStarColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 129: { Vec3f _r = _t->getSymbioticStarColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 130: _t->setEmissionLineStarColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 131: { Vec3f _r = _t->getEmissionLineStarColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 132: _t->setGalaxyClusterColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 133: { Vec3f _r = _t->getGalaxyClusterColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 134: _t->setHintsFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 135: _t->setFlagHints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 136: { bool _r = _t->getFlagHints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 137: _t->setHintsProportional((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 138: { bool _r = _t->getHintsProportional();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 139: _t->setFlagOutlines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 140: { bool _r = _t->getFlagOutlines();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 141: _t->setFlagAdditionalNames((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 142: { bool _r = _t->getFlagAdditionalNames();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 143: _t->setDesignationUsage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 144: { bool _r = _t->getDesignationUsage();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 145: _t->setFlagSurfaceBrightnessUsage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 146: { bool _r = _t->getFlagSurfaceBrightnessUsage();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 147: _t->setFlagSurfaceBrightnessArcsecUsage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 148: { bool _r = _t->getFlagSurfaceBrightnessArcsecUsage();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 149: _t->setFlagSurfaceBrightnessShortNotationUsage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 150: { bool _r = _t->getFlagSurfaceBrightnessShortNotationUsage();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 151: _t->setFlagSizeLimitsUsage((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 152: { bool _r = _t->getFlagSizeLimitsUsage();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 153: _t->setFlagShow((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 154: { bool _r = _t->getFlagShow();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 155: _t->setFlagUseTypeFilters((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 156: { bool _r = _t->getFlagUseTypeFilters();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 157: _t->setFlagShowOnlyNamedDSO((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 158: { bool _r = _t->getFlagShowOnlyNamedDSO();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 159: _t->setMinSizeLimit((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 160: { double _r = _t->getMinSizeLimit();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 161: _t->setMaxSizeLimit((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 162: { double _r = _t->getMaxSizeLimit();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 163: _t->setLabelsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 164: { Vec3f _r = _t->getLabelsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 165: _t->setLabelsAmount((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 166: { double _r = _t->getLabelsAmount();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 167: _t->setHintsAmount((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 168: { double _r = _t->getHintsAmount();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 169: _t->setLabelsBrightness((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 170: { double _r = _t->getLabelsBrightness();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 171: _t->setHintsBrightness((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 172: { double _r = _t->getHintsBrightness();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 173: _t->updateI18n(); break;
        case 174: _t->updateSkyCulture((*reinterpret_cast<std::add_pointer_t<StelSkyCulture>>(_a[1]))); break;
        case 175: { int _r = _t->loadCultureSpecificNames((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 176: _t->loadCultureSpecificNameForNamedObject((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 177: _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 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 20:
            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 21:
            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 22:
            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 24:
            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 25:
            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 26:
            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 28:
            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 29:
            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 30:
            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 32:
            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 33:
            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 34:
            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 35:
            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 37:
            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 39:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 40:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 41:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 42:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 43:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 44:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 45:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 46:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 47:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 48:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 50:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 51:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 52:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 53:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 54:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 66:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 70:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 74:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 78:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 82:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 118:
            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 120:
            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 122:
            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 124:
            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 126:
            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 128:
            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 130:
            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 132:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 163:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagHintsDisplayedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagUseTypeFiltersChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(int )>(_a, &NebulaMgr::catalogFiltersChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(int )>(_a, &NebulaMgr::typeFiltersChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::hintsProportionalChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagOutlinesDisplayedChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagAdditionalNamesDisplayedChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::designationUsageChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagShowOnlyNamedDSOChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagSurfaceBrightnessUsageChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagSurfaceBrightnessArcsecUsageChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagSurfaceBrightnessShortNotationUsageChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(bool )>(_a, &NebulaMgr::flagSizeLimitsUsageChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(double )>(_a, &NebulaMgr::minSizeLimitChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(double )>(_a, &NebulaMgr::maxSizeLimitChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(double )>(_a, &NebulaMgr::labelsAmountChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(double )>(_a, &NebulaMgr::hintsAmountChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(double )>(_a, &NebulaMgr::labelsBrightnessChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(double )>(_a, &NebulaMgr::hintsBrightnessChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::labelsColorChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::circlesColorChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::regionsColorChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::galaxiesColorChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::activeGalaxiesColorChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::radioGalaxiesColorChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::interactingGalaxiesColorChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::quasarsColorChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::possibleQuasarsColorChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::clustersColorChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::openClustersColorChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::globularClustersColorChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::stellarAssociationsColorChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::starCloudsColorChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::starsColorChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::symbioticStarsColorChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::emissionLineStarsColorChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::nebulaeColorChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::planetaryNebulaeColorChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::darkNebulaeColorChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::reflectionNebulaeColorChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::bipolarNebulaeColorChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::emissionNebulaeColorChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::possiblePlanetaryNebulaeColorChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::protoplanetaryNebulaeColorChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::hydrogenRegionsColorChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::interstellarMatterColorChanged, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::emissionObjectsColorChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::molecularCloudsColorChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::blLacObjectsColorChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::blazarsColorChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::youngStellarObjectsColorChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::supernovaRemnantsColorChanged, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::supernovaCandidatesColorChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::supernovaRemnantCandidatesColorChanged, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (NebulaMgr::*)(const Vec3f & ) const>(_a, &NebulaMgr::galaxyClustersColorChanged, 54))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 54:
        case 53:
        case 52:
        case 51:
        case 50:
        case 49:
        case 48:
        case 47:
        case 46:
        case 45:
        case 44:
        case 43:
        case 42:
        case 41:
        case 40:
        case 39:
        case 38:
        case 37:
        case 36:
        case 35:
        case 34:
        case 33:
        case 32:
        case 31:
        case 30:
        case 29:
        case 28:
        case 27:
        case 26:
        case 25:
        case 24:
        case 23:
        case 22:
        case 21:
        case 20:
        case 19:
            *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->getFlagHints(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlagUseTypeFilters(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->getTypeFilters(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->getCatalogFilters(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->getHintsProportional(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->getFlagOutlines(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->getFlagAdditionalNames(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getFlagSurfaceBrightnessUsage(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->getFlagSurfaceBrightnessArcsecUsage(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->getFlagSurfaceBrightnessShortNotationUsage(); break;
        case 10: *reinterpret_cast<double*>(_v) = _t->getLabelsAmount(); break;
        case 11: *reinterpret_cast<double*>(_v) = _t->getHintsAmount(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->getDesignationUsage(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getFlagShowOnlyNamedDSO(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->getFlagSizeLimitsUsage(); break;
        case 15: *reinterpret_cast<double*>(_v) = _t->getMinSizeLimit(); break;
        case 16: *reinterpret_cast<double*>(_v) = _t->getMaxSizeLimit(); break;
        case 17: *reinterpret_cast<double*>(_v) = _t->getHintsBrightness(); break;
        case 18: *reinterpret_cast<double*>(_v) = _t->getLabelsBrightness(); break;
        case 19: *reinterpret_cast<Vec3f*>(_v) = _t->getLabelsColor(); break;
        case 20: *reinterpret_cast<Vec3f*>(_v) = _t->getCirclesColor(); break;
        case 21: *reinterpret_cast<Vec3f*>(_v) = _t->getRegionsColor(); break;
        case 22: *reinterpret_cast<Vec3f*>(_v) = _t->getGalaxyColor(); break;
        case 23: *reinterpret_cast<Vec3f*>(_v) = _t->getActiveGalaxyColor(); break;
        case 24: *reinterpret_cast<Vec3f*>(_v) = _t->getRadioGalaxyColor(); break;
        case 25: *reinterpret_cast<Vec3f*>(_v) = _t->getInteractingGalaxyColor(); break;
        case 26: *reinterpret_cast<Vec3f*>(_v) = _t->getQuasarColor(); break;
        case 27: *reinterpret_cast<Vec3f*>(_v) = _t->getPossibleQuasarColor(); break;
        case 28: *reinterpret_cast<Vec3f*>(_v) = _t->getClusterColor(); break;
        case 29: *reinterpret_cast<Vec3f*>(_v) = _t->getOpenClusterColor(); break;
        case 30: *reinterpret_cast<Vec3f*>(_v) = _t->getGlobularClusterColor(); break;
        case 31: *reinterpret_cast<Vec3f*>(_v) = _t->getStellarAssociationColor(); break;
        case 32: *reinterpret_cast<Vec3f*>(_v) = _t->getStarCloudColor(); break;
        case 33: *reinterpret_cast<Vec3f*>(_v) = _t->getStarColor(); break;
        case 34: *reinterpret_cast<Vec3f*>(_v) = _t->getSymbioticStarColor(); break;
        case 35: *reinterpret_cast<Vec3f*>(_v) = _t->getEmissionLineStarColor(); break;
        case 36: *reinterpret_cast<Vec3f*>(_v) = _t->getNebulaColor(); break;
        case 37: *reinterpret_cast<Vec3f*>(_v) = _t->getPlanetaryNebulaColor(); break;
        case 38: *reinterpret_cast<Vec3f*>(_v) = _t->getDarkNebulaColor(); break;
        case 39: *reinterpret_cast<Vec3f*>(_v) = _t->getReflectionNebulaColor(); break;
        case 40: *reinterpret_cast<Vec3f*>(_v) = _t->getBipolarNebulaColor(); break;
        case 41: *reinterpret_cast<Vec3f*>(_v) = _t->getEmissionNebulaColor(); break;
        case 42: *reinterpret_cast<Vec3f*>(_v) = _t->getPossiblePlanetaryNebulaColor(); break;
        case 43: *reinterpret_cast<Vec3f*>(_v) = _t->getProtoplanetaryNebulaColor(); break;
        case 44: *reinterpret_cast<Vec3f*>(_v) = _t->getHydrogenRegionColor(); break;
        case 45: *reinterpret_cast<Vec3f*>(_v) = _t->getInterstellarMatterColor(); break;
        case 46: *reinterpret_cast<Vec3f*>(_v) = _t->getEmissionObjectColor(); break;
        case 47: *reinterpret_cast<Vec3f*>(_v) = _t->getMolecularCloudColor(); break;
        case 48: *reinterpret_cast<Vec3f*>(_v) = _t->getBlLacObjectColor(); break;
        case 49: *reinterpret_cast<Vec3f*>(_v) = _t->getBlazarColor(); break;
        case 50: *reinterpret_cast<Vec3f*>(_v) = _t->getYoungStellarObjectColor(); break;
        case 51: *reinterpret_cast<Vec3f*>(_v) = _t->getSupernovaRemnantColor(); break;
        case 52: *reinterpret_cast<Vec3f*>(_v) = _t->getSupernovaCandidateColor(); break;
        case 53: *reinterpret_cast<Vec3f*>(_v) = _t->getSupernovaRemnantCandidateColor(); break;
        case 54: *reinterpret_cast<Vec3f*>(_v) = _t->getGalaxyClusterColor(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagHints(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlagUseTypeFilters(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setTypeFilters(*reinterpret_cast<int*>(_v)); break;
        case 3: _t->setCatalogFilters(*reinterpret_cast<int*>(_v)); break;
        case 4: _t->setHintsProportional(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setFlagOutlines(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setFlagAdditionalNames(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setFlagSurfaceBrightnessUsage(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setFlagSurfaceBrightnessArcsecUsage(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setFlagSurfaceBrightnessShortNotationUsage(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setLabelsAmount(*reinterpret_cast<double*>(_v)); break;
        case 11: _t->setHintsAmount(*reinterpret_cast<double*>(_v)); break;
        case 12: _t->setDesignationUsage(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->setFlagShowOnlyNamedDSO(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setFlagSizeLimitsUsage(*reinterpret_cast<bool*>(_v)); break;
        case 15: _t->setMinSizeLimit(*reinterpret_cast<double*>(_v)); break;
        case 16: _t->setMaxSizeLimit(*reinterpret_cast<double*>(_v)); break;
        case 17: _t->setHintsBrightness(*reinterpret_cast<double*>(_v)); break;
        case 18: _t->setLabelsBrightness(*reinterpret_cast<double*>(_v)); break;
        case 19: _t->setLabelsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 20: _t->setCirclesColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 21: _t->setRegionsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 22: _t->setGalaxyColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 23: _t->setActiveGalaxyColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 24: _t->setRadioGalaxyColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 25: _t->setInteractingGalaxyColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 26: _t->setQuasarColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 27: _t->setPossibleQuasarColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 28: _t->setClusterColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 29: _t->setOpenClusterColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 30: _t->setGlobularClusterColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 31: _t->setStellarAssociationColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 32: _t->setStarCloudColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 33: _t->setStarColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 34: _t->setSymbioticStarColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 35: _t->setEmissionLineStarColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 36: _t->setNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 37: _t->setPlanetaryNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 38: _t->setDarkNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 39: _t->setReflectionNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 40: _t->setBipolarNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 41: _t->setEmissionNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 42: _t->setPossiblePlanetaryNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 43: _t->setProtoplanetaryNebulaColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 44: _t->setHydrogenRegionColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 45: _t->setInterstellarMatterColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 46: _t->setEmissionObjectColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 47: _t->setMolecularCloudColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 48: _t->setBlLacObjectColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 49: _t->setBlazarColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 50: _t->setYoungStellarObjectColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 51: _t->setSupernovaRemnantColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 52: _t->setSupernovaCandidateColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 53: _t->setSupernovaRemnantCandidateColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 54: _t->setGalaxyClusterColor(*reinterpret_cast<Vec3f*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

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

// SIGNAL 2
void NebulaMgr::catalogFiltersChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void NebulaMgr::typeFiltersChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

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

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

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

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

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

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

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

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

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

// SIGNAL 13
void NebulaMgr::minSizeLimitChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void NebulaMgr::maxSizeLimitChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

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

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

// SIGNAL 17
void NebulaMgr::labelsBrightnessChanged(double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

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

// SIGNAL 19
void NebulaMgr::labelsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void NebulaMgr::circlesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void NebulaMgr::regionsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void NebulaMgr::galaxiesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void NebulaMgr::activeGalaxiesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void NebulaMgr::radioGalaxiesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void NebulaMgr::interactingGalaxiesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void NebulaMgr::quasarsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void NebulaMgr::possibleQuasarsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void NebulaMgr::clustersColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void NebulaMgr::openClustersColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void NebulaMgr::globularClustersColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void NebulaMgr::stellarAssociationsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void NebulaMgr::starCloudsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void NebulaMgr::starsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void NebulaMgr::symbioticStarsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void NebulaMgr::emissionLineStarsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void NebulaMgr::nebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void NebulaMgr::planetaryNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void NebulaMgr::darkNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void NebulaMgr::reflectionNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void NebulaMgr::bipolarNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void NebulaMgr::emissionNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void NebulaMgr::possiblePlanetaryNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void NebulaMgr::protoplanetaryNebulaeColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 43, nullptr, _t1);
}

// SIGNAL 44
void NebulaMgr::hydrogenRegionsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void NebulaMgr::interstellarMatterColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 45, nullptr, _t1);
}

// SIGNAL 46
void NebulaMgr::emissionObjectsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void NebulaMgr::molecularCloudsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 47, nullptr, _t1);
}

// SIGNAL 48
void NebulaMgr::blLacObjectsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void NebulaMgr::blazarsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 49, nullptr, _t1);
}

// SIGNAL 50
void NebulaMgr::youngStellarObjectsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 50, nullptr, _t1);
}

// SIGNAL 51
void NebulaMgr::supernovaRemnantsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 51, nullptr, _t1);
}

// SIGNAL 52
void NebulaMgr::supernovaCandidatesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void NebulaMgr::supernovaRemnantCandidatesColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 53, nullptr, _t1);
}

// SIGNAL 54
void NebulaMgr::galaxyClustersColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< NebulaMgr *>(this), &staticMetaObject, 54, nullptr, _t1);
}
QT_WARNING_POP
