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

template <> constexpr inline auto ConstellationMgr::qt_create_metaobjectdata<qt_meta_tag_ZN16ConstellationMgrE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ConstellationMgr",
        "artDisplayedChanged",
        "",
        "displayed",
        "artFadeDurationChanged",
        "duration",
        "artIntensityChanged",
        "intensity",
        "boundariesColorChanged",
        "Vec3f",
        "color",
        "boundariesDisplayedChanged",
        "boundariesFadeDurationChanged",
        "boundariesThicknessChanged",
        "thickness",
        "hullsColorChanged",
        "hullsDisplayedChanged",
        "hullsFadeDurationChanged",
        "hullsThicknessChanged",
        "zodiacColorChanged",
        "zodiacDisplayedChanged",
        "zodiacFadeDurationChanged",
        "zodiacThicknessChanged",
        "lunarSystemColorChanged",
        "lunarSystemDisplayedChanged",
        "lunarSystemFadeDurationChanged",
        "lunarSystemThicknessChanged",
        "fontSizeChanged",
        "newSize",
        "isolateSelectedChanged",
        "isolate",
        "flagConstellationPickChanged",
        "mode",
        "linesColorChanged",
        "linesDisplayedChanged",
        "linesFadeDurationChanged",
        "namesColorChanged",
        "namesDisplayedChanged",
        "namesFadeDurationChanged",
        "constellationsDisplayStyleChanged",
        "StelObject::CulturalDisplayStyle",
        "style",
        "constellationLineThicknessChanged",
        "hasUpdatedSkyCulture",
        "setFlagArt",
        "getFlagArt",
        "setArtFadeDuration",
        "getArtFadeDuration",
        "setArtIntensity",
        "getArtIntensity",
        "setArtIntensityMinimumFov",
        "fov",
        "getArtIntensityMinimumFov",
        "setArtIntensityMaximumFov",
        "getArtIntensityMaximumFov",
        "setBoundariesColor",
        "getBoundariesColor",
        "setFlagBoundaries",
        "getFlagBoundaries",
        "setBoundariesFadeDuration",
        "getBoundariesFadeDuration",
        "setFlagIsolateSelected",
        "getFlagIsolateSelected",
        "setFlagConstellationPick",
        "getFlagConstellationPick",
        "setLinesColor",
        "getLinesColor",
        "setFlagLines",
        "getFlagLines",
        "setLinesFadeDuration",
        "getLinesFadeDuration",
        "setLabelsColor",
        "getLabelsColor",
        "setFlagLabels",
        "getFlagLabels",
        "setLabelsFadeDuration",
        "getLabelsFadeDuration",
        "setHullsColor",
        "getHullsColor",
        "setFlagHulls",
        "getFlagHulls",
        "setHullsFadeDuration",
        "getHullsFadeDuration",
        "setFontSize",
        "newFontSize",
        "getFontSize",
        "setConstellationLineThickness",
        "getConstellationLineThickness",
        "setBoundariesThickness",
        "getBoundariesThickness",
        "setHullsThickness",
        "getHullsThickness",
        "setZodiacColor",
        "getZodiacColor",
        "setFlagZodiac",
        "getFlagZodiac",
        "setZodiacFadeDuration",
        "getZodiacFadeDuration",
        "setLunarSystemColor",
        "getLunarSystemColor",
        "setFlagLunarSystem",
        "getFlagLunarSystem",
        "setLunarSystemFadeDuration",
        "getLunarSystemFadeDuration",
        "setZodiacThickness",
        "getZodiacThickness",
        "setLunarSystemThickness",
        "getLunarSystemThickness",
        "deselectConstellations",
        "selectAllConstellations",
        "selectConstellation",
        "englishName",
        "selectConstellationByObjectName",
        "deselectConstellation",
        "getConstellationsEnglishNames",
        "outputHullAreas",
        "fileNamePrefix",
        "starsInHullOf",
        "hipOnly",
        "maxMag",
        "selectedObjectChange",
        "StelModule::StelModuleSelectAction",
        "action",
        "updateSkyCulture",
        "StelSkyCulture",
        "skyCulture",
        "updateI18n",
        "reloadSkyCulture",
        "artDisplayed",
        "artFadeDuration",
        "artIntensity",
        "boundariesColor",
        "boundariesDisplayed",
        "boundariesFadeDuration",
        "fontSize",
        "isolateSelected",
        "flagConstellationPick",
        "linesColor",
        "linesDisplayed",
        "linesFadeDuration",
        "namesColor",
        "namesDisplayed",
        "namesFadeDuration",
        "constellationLineThickness",
        "boundariesThickness",
        "hullsDisplayed",
        "hullsColor",
        "hullsThickness",
        "hullsFadeDuration",
        "zodiacDisplayed",
        "zodiacColor",
        "zodiacThickness",
        "zodiacFadeDuration",
        "lunarSystemDisplayed",
        "lunarSystemColor",
        "lunarSystemThickness",
        "lunarSystemFadeDuration"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'artDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'artFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'artIntensityChanged'
        QtMocHelpers::SignalData<void(const double)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 7 },
        }}),
        // Signal 'boundariesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'boundariesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'boundariesFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'boundariesThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'hullsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'hullsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'hullsFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'hullsThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'zodiacColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'zodiacDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'zodiacFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'zodiacThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'lunarSystemColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'lunarSystemDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'lunarSystemFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'lunarSystemThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'fontSizeChanged'
        QtMocHelpers::SignalData<void(const int)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 28 },
        }}),
        // Signal 'isolateSelectedChanged'
        QtMocHelpers::SignalData<void(const bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 30 },
        }}),
        // Signal 'flagConstellationPickChanged'
        QtMocHelpers::SignalData<void(const bool)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 32 },
        }}),
        // Signal 'linesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'linesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'linesFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'namesColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Signal 'namesDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'namesFadeDurationChanged'
        QtMocHelpers::SignalData<void(const float)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Signal 'constellationsDisplayStyleChanged'
        QtMocHelpers::SignalData<void(const StelObject::CulturalDisplayStyle)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 40, 41 },
        }}),
        // Signal 'constellationLineThicknessChanged'
        QtMocHelpers::SignalData<void(int)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Signal 'hasUpdatedSkyCulture'
        QtMocHelpers::SignalData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFlagArt'
        QtMocHelpers::SlotData<void(const bool)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagArt'
        QtMocHelpers::SlotData<bool() const>(45, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setArtFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getArtFadeDuration'
        QtMocHelpers::SlotData<float() const>(47, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setArtIntensity'
        QtMocHelpers::SlotData<void(const float)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 7 },
        }}),
        // Slot 'getArtIntensity'
        QtMocHelpers::SlotData<float() const>(49, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setArtIntensityMinimumFov'
        QtMocHelpers::SlotData<void(const double)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 51 },
        }}),
        // Slot 'getArtIntensityMinimumFov'
        QtMocHelpers::SlotData<double() const>(52, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setArtIntensityMaximumFov'
        QtMocHelpers::SlotData<void(const double)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 51 },
        }}),
        // Slot 'getArtIntensityMaximumFov'
        QtMocHelpers::SlotData<double() const>(54, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setBoundariesColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'getBoundariesColor'
        QtMocHelpers::SlotData<Vec3f() const>(56, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setFlagBoundaries'
        QtMocHelpers::SlotData<void(const bool)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagBoundaries'
        QtMocHelpers::SlotData<bool() const>(58, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setBoundariesFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getBoundariesFadeDuration'
        QtMocHelpers::SlotData<float() const>(60, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setFlagIsolateSelected'
        QtMocHelpers::SlotData<void(const bool)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 30 },
        }}),
        // Slot 'getFlagIsolateSelected'
        QtMocHelpers::SlotData<bool() const>(62, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagConstellationPick'
        QtMocHelpers::SlotData<void(const bool)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 32 },
        }}),
        // Slot 'getFlagConstellationPick'
        QtMocHelpers::SlotData<bool() const>(64, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLinesColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'getLinesColor'
        QtMocHelpers::SlotData<Vec3f() const>(66, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setFlagLines'
        QtMocHelpers::SlotData<void(const bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagLines'
        QtMocHelpers::SlotData<bool() const>(68, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLinesFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getLinesFadeDuration'
        QtMocHelpers::SlotData<float() const>(70, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setLabelsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'getLabelsColor'
        QtMocHelpers::SlotData<Vec3f() const>(72, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setFlagLabels'
        QtMocHelpers::SlotData<void(const bool)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagLabels'
        QtMocHelpers::SlotData<bool() const>(74, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLabelsFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getLabelsFadeDuration'
        QtMocHelpers::SlotData<float() const>(76, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setHullsColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'getHullsColor'
        QtMocHelpers::SlotData<Vec3f() const>(78, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setFlagHulls'
        QtMocHelpers::SlotData<void(const bool)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagHulls'
        QtMocHelpers::SlotData<bool() const>(80, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setHullsFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getHullsFadeDuration'
        QtMocHelpers::SlotData<float() const>(82, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setFontSize'
        QtMocHelpers::SlotData<void(const int)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 84 },
        }}),
        // Slot 'getFontSize'
        QtMocHelpers::SlotData<int() const>(85, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setConstellationLineThickness'
        QtMocHelpers::SlotData<void(const int)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getConstellationLineThickness'
        QtMocHelpers::SlotData<int() const>(87, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBoundariesThickness'
        QtMocHelpers::SlotData<void(const int)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getBoundariesThickness'
        QtMocHelpers::SlotData<int() const>(89, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setHullsThickness'
        QtMocHelpers::SlotData<void(const int)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getHullsThickness'
        QtMocHelpers::SlotData<int() const>(91, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setZodiacColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'getZodiacColor'
        QtMocHelpers::SlotData<Vec3f() const>(93, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setFlagZodiac'
        QtMocHelpers::SlotData<void(const bool)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagZodiac'
        QtMocHelpers::SlotData<bool() const>(95, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setZodiacFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getZodiacFadeDuration'
        QtMocHelpers::SlotData<float() const>(97, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setLunarSystemColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 },
        }}),
        // Slot 'getLunarSystemColor'
        QtMocHelpers::SlotData<Vec3f() const>(99, 2, QMC::AccessPublic, 0x80000000 | 9),
        // Slot 'setFlagLunarSystem'
        QtMocHelpers::SlotData<void(const bool)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagLunarSystem'
        QtMocHelpers::SlotData<bool() const>(101, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLunarSystemFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 5 },
        }}),
        // Slot 'getLunarSystemFadeDuration'
        QtMocHelpers::SlotData<float() const>(103, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setZodiacThickness'
        QtMocHelpers::SlotData<void(const int)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getZodiacThickness'
        QtMocHelpers::SlotData<int() const>(105, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLunarSystemThickness'
        QtMocHelpers::SlotData<void(const int)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 },
        }}),
        // Slot 'getLunarSystemThickness'
        QtMocHelpers::SlotData<int() const>(107, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'deselectConstellations'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectAllConstellations'
        QtMocHelpers::SlotData<void()>(109, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectConstellation'
        QtMocHelpers::SlotData<void(const QString &)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 111 },
        }}),
        // Slot 'selectConstellationByObjectName'
        QtMocHelpers::SlotData<void(const QString &)>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 111 },
        }}),
        // Slot 'deselectConstellation'
        QtMocHelpers::SlotData<void(const QString &)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 111 },
        }}),
        // Slot 'getConstellationsEnglishNames'
        QtMocHelpers::SlotData<QStringList()>(114, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'outputHullAreas'
        QtMocHelpers::SlotData<void(const QString &) const>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 116 },
        }}),
        // Slot 'outputHullAreas'
        QtMocHelpers::SlotData<void() const>(115, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'starsInHullOf'
        QtMocHelpers::SlotData<void(const QString &, const bool, const float, const QString &) const>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 111 }, { QMetaType::Bool, 118 }, { QMetaType::Float, 119 }, { QMetaType::QString, 116 },
        }}),
        // Slot 'starsInHullOf'
        QtMocHelpers::SlotData<void(const QString &, const bool, const float) const>(117, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 111 }, { QMetaType::Bool, 118 }, { QMetaType::Float, 119 },
        }}),
        // Slot 'starsInHullOf'
        QtMocHelpers::SlotData<void(const QString &, const bool) const>(117, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 111 }, { QMetaType::Bool, 118 },
        }}),
        // Slot 'starsInHullOf'
        QtMocHelpers::SlotData<void(const QString &) const>(117, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 111 },
        }}),
        // Slot 'selectedObjectChange'
        QtMocHelpers::SlotData<void(StelModule::StelModuleSelectAction)>(120, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 121, 122 },
        }}),
        // Slot 'updateSkyCulture'
        QtMocHelpers::SlotData<void(const StelSkyCulture &)>(123, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 124, 125 },
        }}),
        // Slot 'updateI18n'
        QtMocHelpers::SlotData<void()>(126, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'reloadSkyCulture'
        QtMocHelpers::SlotData<void()>(127, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'artDisplayed'
        QtMocHelpers::PropertyData<bool>(128, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'artFadeDuration'
        QtMocHelpers::PropertyData<float>(129, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'artIntensity'
        QtMocHelpers::PropertyData<float>(130, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'boundariesColor'
        QtMocHelpers::PropertyData<Vec3f>(131, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 3),
        // property 'boundariesDisplayed'
        QtMocHelpers::PropertyData<bool>(132, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 4),
        // property 'boundariesFadeDuration'
        QtMocHelpers::PropertyData<float>(133, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'fontSize'
        QtMocHelpers::PropertyData<int>(134, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'isolateSelected'
        QtMocHelpers::PropertyData<bool>(135, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 20),
        // property 'flagConstellationPick'
        QtMocHelpers::PropertyData<bool>(136, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'linesColor'
        QtMocHelpers::PropertyData<Vec3f>(137, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 22),
        // property 'linesDisplayed'
        QtMocHelpers::PropertyData<bool>(138, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 23),
        // property 'linesFadeDuration'
        QtMocHelpers::PropertyData<float>(139, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'namesColor'
        QtMocHelpers::PropertyData<Vec3f>(140, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 25),
        // property 'namesDisplayed'
        QtMocHelpers::PropertyData<bool>(141, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 26),
        // property 'namesFadeDuration'
        QtMocHelpers::PropertyData<float>(142, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 27),
        // property 'constellationLineThickness'
        QtMocHelpers::PropertyData<int>(143, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'boundariesThickness'
        QtMocHelpers::PropertyData<int>(144, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'hullsDisplayed'
        QtMocHelpers::PropertyData<bool>(145, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 8),
        // property 'hullsColor'
        QtMocHelpers::PropertyData<Vec3f>(146, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 7),
        // property 'hullsThickness'
        QtMocHelpers::PropertyData<int>(147, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'hullsFadeDuration'
        QtMocHelpers::PropertyData<float>(148, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'zodiacDisplayed'
        QtMocHelpers::PropertyData<bool>(149, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'zodiacColor'
        QtMocHelpers::PropertyData<Vec3f>(150, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11),
        // property 'zodiacThickness'
        QtMocHelpers::PropertyData<int>(151, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'zodiacFadeDuration'
        QtMocHelpers::PropertyData<float>(152, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'lunarSystemDisplayed'
        QtMocHelpers::PropertyData<bool>(153, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 16),
        // property 'lunarSystemColor'
        QtMocHelpers::PropertyData<Vec3f>(154, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 15),
        // property 'lunarSystemThickness'
        QtMocHelpers::PropertyData<int>(155, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'lunarSystemFadeDuration'
        QtMocHelpers::PropertyData<float>(156, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ConstellationMgr, qt_meta_tag_ZN16ConstellationMgrE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ConstellationMgr::staticMetaObject = { {
    QMetaObject::SuperData::link<StelObjectModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ConstellationMgrE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ConstellationMgrE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16ConstellationMgrE_t>.metaTypes,
    nullptr
} };

void ConstellationMgr::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ConstellationMgr *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->artDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->artFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 2: _t->artIntensityChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 3: _t->boundariesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 4: _t->boundariesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 5: _t->boundariesFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 6: _t->boundariesThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 7: _t->hullsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 8: _t->hullsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->hullsFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 10: _t->hullsThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->zodiacColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 12: _t->zodiacDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->zodiacFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 14: _t->zodiacThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 15: _t->lunarSystemColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 16: _t->lunarSystemDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->lunarSystemFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 18: _t->lunarSystemThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 19: _t->fontSizeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 20: _t->isolateSelectedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->flagConstellationPickChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->linesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 23: _t->linesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->linesFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 25: _t->namesColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 26: _t->namesDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->namesFadeDurationChanged((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 28: _t->constellationsDisplayStyleChanged((*reinterpret_cast<std::add_pointer_t<StelObject::CulturalDisplayStyle>>(_a[1]))); break;
        case 29: _t->constellationLineThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 30: _t->hasUpdatedSkyCulture(); break;
        case 31: _t->setFlagArt((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 32: { bool _r = _t->getFlagArt();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 33: _t->setArtFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 34: { float _r = _t->getArtFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 35: _t->setArtIntensity((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 36: { float _r = _t->getArtIntensity();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 37: _t->setArtIntensityMinimumFov((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 38: { double _r = _t->getArtIntensityMinimumFov();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 39: _t->setArtIntensityMaximumFov((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 40: { double _r = _t->getArtIntensityMaximumFov();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 41: _t->setBoundariesColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 42: { Vec3f _r = _t->getBoundariesColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 43: _t->setFlagBoundaries((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: { bool _r = _t->getFlagBoundaries();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 45: _t->setBoundariesFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 46: { float _r = _t->getBoundariesFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 47: _t->setFlagIsolateSelected((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: { bool _r = _t->getFlagIsolateSelected();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: _t->setFlagConstellationPick((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 50: { bool _r = _t->getFlagConstellationPick();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 51: _t->setLinesColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 52: { Vec3f _r = _t->getLinesColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 53: _t->setFlagLines((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: { bool _r = _t->getFlagLines();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 55: _t->setLinesFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 56: { float _r = _t->getLinesFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->setLabelsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 58: { Vec3f _r = _t->getLabelsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 59: _t->setFlagLabels((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 60: { bool _r = _t->getFlagLabels();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 61: _t->setLabelsFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 62: { float _r = _t->getLabelsFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 63: _t->setHullsColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 64: { Vec3f _r = _t->getHullsColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 65: _t->setFlagHulls((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 66: { bool _r = _t->getFlagHulls();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 67: _t->setHullsFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 68: { float _r = _t->getHullsFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 69: _t->setFontSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 70: { int _r = _t->getFontSize();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 71: _t->setConstellationLineThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 72: { int _r = _t->getConstellationLineThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 73: _t->setBoundariesThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 74: { int _r = _t->getBoundariesThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 75: _t->setHullsThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 76: { int _r = _t->getHullsThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 77: _t->setZodiacColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 78: { Vec3f _r = _t->getZodiacColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 79: _t->setFlagZodiac((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 80: { bool _r = _t->getFlagZodiac();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 81: _t->setZodiacFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 82: { float _r = _t->getZodiacFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 83: _t->setLunarSystemColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 84: { Vec3f _r = _t->getLunarSystemColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 85: _t->setFlagLunarSystem((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 86: { bool _r = _t->getFlagLunarSystem();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 87: _t->setLunarSystemFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 88: { float _r = _t->getLunarSystemFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 89: _t->setZodiacThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 90: { int _r = _t->getZodiacThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 91: _t->setLunarSystemThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 92: { int _r = _t->getLunarSystemThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 93: _t->deselectConstellations(); break;
        case 94: _t->selectAllConstellations(); break;
        case 95: _t->selectConstellation((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 96: _t->selectConstellationByObjectName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 97: _t->deselectConstellation((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 98: { QStringList _r = _t->getConstellationsEnglishNames();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 99: _t->outputHullAreas((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 100: _t->outputHullAreas(); break;
        case 101: _t->starsInHullOf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 102: _t->starsInHullOf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[3]))); break;
        case 103: _t->starsInHullOf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 104: _t->starsInHullOf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 105: _t->selectedObjectChange((*reinterpret_cast<std::add_pointer_t<StelModule::StelModuleSelectAction>>(_a[1]))); break;
        case 106: _t->updateSkyCulture((*reinterpret_cast<std::add_pointer_t<StelSkyCulture>>(_a[1]))); break;
        case 107: _t->updateI18n(); break;
        case 108: _t->reloadSkyCulture(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 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 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 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 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 57:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 63:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 77:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 83:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 105:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelModule::StelModuleSelectAction >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::artDisplayedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::artFadeDurationChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const double )>(_a, &ConstellationMgr::artIntensityChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const Vec3f & )>(_a, &ConstellationMgr::boundariesColorChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::boundariesDisplayedChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::boundariesFadeDurationChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(int )>(_a, &ConstellationMgr::boundariesThicknessChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const Vec3f & )>(_a, &ConstellationMgr::hullsColorChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::hullsDisplayedChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::hullsFadeDurationChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(int )>(_a, &ConstellationMgr::hullsThicknessChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const Vec3f & )>(_a, &ConstellationMgr::zodiacColorChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::zodiacDisplayedChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::zodiacFadeDurationChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(int )>(_a, &ConstellationMgr::zodiacThicknessChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const Vec3f & )>(_a, &ConstellationMgr::lunarSystemColorChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::lunarSystemDisplayedChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::lunarSystemFadeDurationChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(int )>(_a, &ConstellationMgr::lunarSystemThicknessChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const int )>(_a, &ConstellationMgr::fontSizeChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::isolateSelectedChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::flagConstellationPickChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const Vec3f & )>(_a, &ConstellationMgr::linesColorChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::linesDisplayedChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::linesFadeDurationChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const Vec3f & )>(_a, &ConstellationMgr::namesColorChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const bool )>(_a, &ConstellationMgr::namesDisplayedChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const float )>(_a, &ConstellationMgr::namesFadeDurationChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(const StelObject::CulturalDisplayStyle )>(_a, &ConstellationMgr::constellationsDisplayStyleChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)(int )>(_a, &ConstellationMgr::constellationLineThicknessChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (ConstellationMgr::*)()>(_a, &ConstellationMgr::hasUpdatedSkyCulture, 30))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 26:
        case 22:
        case 18:
        case 12:
        case 9:
        case 3:
            *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->getFlagArt(); break;
        case 1: *reinterpret_cast<float*>(_v) = _t->getArtFadeDuration(); break;
        case 2: *reinterpret_cast<float*>(_v) = _t->getArtIntensity(); break;
        case 3: *reinterpret_cast<Vec3f*>(_v) = _t->getBoundariesColor(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->getFlagBoundaries(); break;
        case 5: *reinterpret_cast<float*>(_v) = _t->getBoundariesFadeDuration(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->getFontSize(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getFlagIsolateSelected(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->getFlagConstellationPick(); break;
        case 9: *reinterpret_cast<Vec3f*>(_v) = _t->getLinesColor(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->getFlagLines(); break;
        case 11: *reinterpret_cast<float*>(_v) = _t->getLinesFadeDuration(); break;
        case 12: *reinterpret_cast<Vec3f*>(_v) = _t->getLabelsColor(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getFlagLabels(); break;
        case 14: *reinterpret_cast<float*>(_v) = _t->getLabelsFadeDuration(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->getConstellationLineThickness(); break;
        case 16: *reinterpret_cast<int*>(_v) = _t->getBoundariesThickness(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->getFlagHulls(); break;
        case 18: *reinterpret_cast<Vec3f*>(_v) = _t->getHullsColor(); break;
        case 19: *reinterpret_cast<int*>(_v) = _t->getHullsThickness(); break;
        case 20: *reinterpret_cast<float*>(_v) = _t->getHullsFadeDuration(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->getFlagZodiac(); break;
        case 22: *reinterpret_cast<Vec3f*>(_v) = _t->getZodiacColor(); break;
        case 23: *reinterpret_cast<int*>(_v) = _t->getZodiacThickness(); break;
        case 24: *reinterpret_cast<float*>(_v) = _t->getZodiacFadeDuration(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->getFlagLunarSystem(); break;
        case 26: *reinterpret_cast<Vec3f*>(_v) = _t->getLunarSystemColor(); break;
        case 27: *reinterpret_cast<int*>(_v) = _t->getLunarSystemThickness(); break;
        case 28: *reinterpret_cast<float*>(_v) = _t->getLunarSystemFadeDuration(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagArt(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setArtFadeDuration(*reinterpret_cast<float*>(_v)); break;
        case 2: _t->setArtIntensity(*reinterpret_cast<float*>(_v)); break;
        case 3: _t->setBoundariesColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 4: _t->setFlagBoundaries(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setBoundariesFadeDuration(*reinterpret_cast<float*>(_v)); break;
        case 6: _t->setFontSize(*reinterpret_cast<int*>(_v)); break;
        case 7: _t->setFlagIsolateSelected(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setFlagConstellationPick(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setLinesColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 10: _t->setFlagLines(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setLinesFadeDuration(*reinterpret_cast<float*>(_v)); break;
        case 12: _t->setLabelsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 13: _t->setFlagLabels(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setLabelsFadeDuration(*reinterpret_cast<float*>(_v)); break;
        case 15: _t->setConstellationLineThickness(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setBoundariesThickness(*reinterpret_cast<int*>(_v)); break;
        case 17: _t->setFlagHulls(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setHullsColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 19: _t->setHullsThickness(*reinterpret_cast<int*>(_v)); break;
        case 20: _t->setHullsFadeDuration(*reinterpret_cast<float*>(_v)); break;
        case 21: _t->setFlagZodiac(*reinterpret_cast<bool*>(_v)); break;
        case 22: _t->setZodiacColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 23: _t->setZodiacThickness(*reinterpret_cast<int*>(_v)); break;
        case 24: _t->setZodiacFadeDuration(*reinterpret_cast<float*>(_v)); break;
        case 25: _t->setFlagLunarSystem(*reinterpret_cast<bool*>(_v)); break;
        case 26: _t->setLunarSystemColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 27: _t->setLunarSystemThickness(*reinterpret_cast<int*>(_v)); break;
        case 28: _t->setLunarSystemFadeDuration(*reinterpret_cast<float*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

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

// SIGNAL 2
void ConstellationMgr::artIntensityChanged(const double _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void ConstellationMgr::boundariesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

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

// SIGNAL 5
void ConstellationMgr::boundariesFadeDurationChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void ConstellationMgr::boundariesThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

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

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

// SIGNAL 9
void ConstellationMgr::hullsFadeDurationChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

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

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

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

// SIGNAL 13
void ConstellationMgr::zodiacFadeDurationChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void ConstellationMgr::zodiacThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

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

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

// SIGNAL 17
void ConstellationMgr::lunarSystemFadeDurationChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void ConstellationMgr::lunarSystemThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

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

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

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

// SIGNAL 22
void ConstellationMgr::linesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

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

// SIGNAL 24
void ConstellationMgr::linesFadeDurationChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void ConstellationMgr::namesColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

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

// SIGNAL 27
void ConstellationMgr::namesFadeDurationChanged(const float _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void ConstellationMgr::constellationsDisplayStyleChanged(const StelObject::CulturalDisplayStyle _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void ConstellationMgr::constellationLineThicknessChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void ConstellationMgr::hasUpdatedSkyCulture()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}
QT_WARNING_POP
