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

template <> constexpr inline auto Cardinals::qt_create_metaobjectdata<qt_meta_tag_ZN9CardinalsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Cardinals",
        "CompassDirection",
        "dN",
        "dS",
        "dE",
        "dW",
        "dNE",
        "dSE",
        "dNW",
        "dSW",
        "dNNE",
        "dENE",
        "dESE",
        "dSSE",
        "dSSW",
        "dWSW",
        "dWNW",
        "dNNW",
        "dNbE",
        "dNEbN",
        "dNEbE",
        "dEbN",
        "dEbS",
        "dSEbE",
        "dSEbS",
        "dSbE",
        "dSbW",
        "dSWbS",
        "dSWbW",
        "dWbS",
        "dWbN",
        "dNWbW",
        "dNWbN",
        "dNbW"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'CompassDirection'
        QtMocHelpers::EnumData<enum CompassDirection>(1, 1, QMC::EnumFlags{}).add({
            {    2, CompassDirection::dN },
            {    3, CompassDirection::dS },
            {    4, CompassDirection::dE },
            {    5, CompassDirection::dW },
            {    6, CompassDirection::dNE },
            {    7, CompassDirection::dSE },
            {    8, CompassDirection::dNW },
            {    9, CompassDirection::dSW },
            {   10, CompassDirection::dNNE },
            {   11, CompassDirection::dENE },
            {   12, CompassDirection::dESE },
            {   13, CompassDirection::dSSE },
            {   14, CompassDirection::dSSW },
            {   15, CompassDirection::dWSW },
            {   16, CompassDirection::dWNW },
            {   17, CompassDirection::dNNW },
            {   18, CompassDirection::dNbE },
            {   19, CompassDirection::dNEbN },
            {   20, CompassDirection::dNEbE },
            {   21, CompassDirection::dEbN },
            {   22, CompassDirection::dEbS },
            {   23, CompassDirection::dSEbE },
            {   24, CompassDirection::dSEbS },
            {   25, CompassDirection::dSbE },
            {   26, CompassDirection::dSbW },
            {   27, CompassDirection::dSWbS },
            {   28, CompassDirection::dSWbW },
            {   29, CompassDirection::dWbS },
            {   30, CompassDirection::dWbN },
            {   31, CompassDirection::dNWbW },
            {   32, CompassDirection::dNWbN },
            {   33, CompassDirection::dNbW },
        }),
    };
    return QtMocHelpers::metaObjectData<Cardinals, qt_meta_tag_ZN9CardinalsE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Cardinals::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9CardinalsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9CardinalsE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9CardinalsE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN12LandscapeMgrE_t {};
} // unnamed namespace

template <> constexpr inline auto LandscapeMgr::qt_create_metaobjectdata<qt_meta_tag_ZN12LandscapeMgrE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LandscapeMgr",
        "atmosphereDisplayedChanged",
        "",
        "displayed",
        "atmosphereModelChanged",
        "model",
        "atmosphereModelPathChanged",
        "atmosphereStoppedWithErrorChanged",
        "error",
        "atmosphereStatusTextChanged",
        "status",
        "flagAtmosphereZeroOrderScatteringChanged",
        "value",
        "flagAtmosphereSingleScatteringChanged",
        "flagAtmosphereMultipleScatteringChanged",
        "flagAtmospherePseudoMirrorChanged",
        "atmosphereEclipseSimulationQualityChanged",
        "quality",
        "atmosphereNoScatterChanged",
        "noScatter",
        "cardinalPointsDisplayedChanged",
        "ordinalPointsDisplayedChanged",
        "ordinal16WRPointsDisplayedChanged",
        "ordinal32WRPointsDisplayedChanged",
        "cardinalPointsColorChanged",
        "Vec3f",
        "newColor",
        "fogDisplayedChanged",
        "landscapeDisplayedChanged",
        "illuminationDisplayedChanged",
        "labelsDisplayedChanged",
        "labelFontSizeChanged",
        "size",
        "labelColorChanged",
        "c",
        "labelAngleChanged",
        "angleDeg",
        "flagPolyLineOnlyDisplayedChanged",
        "enabled",
        "polyLineThicknessChanged",
        "thickness",
        "polyLineColorChanged",
        "flagUseLightPollutionFromDatabaseChanged",
        "usage",
        "flagLandscapeAutoSelectionChanged",
        "flagLandscapeSetsLocationChanged",
        "flagLandscapeUseMinimalBrightnessChanged",
        "flagLandscapeSetsMinimalBrightnessChanged",
        "defaultMinimalBrightnessChanged",
        "setFlagEnvironmentAutoEnableChanged",
        "landscapeTransparencyChanged",
        "flagLandscapeUseTransparencyChanged",
        "defaultLandscapeChanged",
        "id",
        "landscapesChanged",
        "errorUnableToOpen",
        "path",
        "errorNotArchive",
        "errorNotUnique",
        "nameOrID",
        "errorRemoveManually",
        "currentLandscapeChanged",
        "currentLandscapeID",
        "currentLandscapeName",
        "getLuminance",
        "getAtmosphereAverageLuminance",
        "setAtmosphereAverageLuminance",
        "overrideLuminance",
        "getNameToDirMap",
        "QMap<QString,QString>",
        "getAllLandscapeNames",
        "getAllLandscapeIDs",
        "getUserLandscapeIDs",
        "getCurrentLandscapeID",
        "setCurrentLandscapeID",
        "changeLocationDuration",
        "getCurrentLandscapeName",
        "setCurrentLandscapeName",
        "name",
        "getCurrentLandscapeBrightness",
        "light",
        "precacheLandscape",
        "replace",
        "removeCachedLandscape",
        "setCacheSize",
        "mb",
        "getCacheSize",
        "getCacheFilledSize",
        "getCacheCount",
        "getCurrentLandscape",
        "Landscape*",
        "getDefaultLandscapeID",
        "setDefaultLandscapeID",
        "getCurrentLandscapeHtmlDescription",
        "getDescription",
        "getFlagLandscape",
        "setFlagLandscape",
        "getIsLandscapeFullyVisible",
        "getLandscapeSinMinAltitudeLimit",
        "getFlagFog",
        "setFlagFog",
        "getFlagIllumination",
        "setFlagIllumination",
        "on",
        "getFlagLabels",
        "setFlagLabels",
        "getLabelFontSize",
        "setLabelFontSize",
        "getLabelAngle",
        "setLabelAngle",
        "getLabelColor",
        "setLabelColor",
        "getFlagPolyLineOnlyDisplayed",
        "setFlagPolyLineOnlyDisplayed",
        "b",
        "getPolyLineThickness",
        "setPolyLineThickness",
        "getPolyLineColor",
        "setPolyLineColor",
        "getFlagLandscapeSetsLocation",
        "setFlagLandscapeSetsLocation",
        "getFlagLandscapeUseMinimalBrightness",
        "setFlagLandscapeUseMinimalBrightness",
        "getFlagLandscapeSetsMinimalBrightness",
        "setFlagLandscapeSetsMinimalBrightness",
        "getDefaultMinimalBrightness",
        "setDefaultMinimalBrightness",
        "setFlagUseLightPollutionFromDatabase",
        "getFlagUseLightPollutionFromDatabase",
        "getFlagCardinalPoints",
        "setFlagCardinalPoints",
        "getFlagOrdinalPoints",
        "setFlagOrdinalPoints",
        "getFlagOrdinal16WRPoints",
        "setFlagOrdinal16WRPoints",
        "getFlagOrdinal32WRPoints",
        "setFlagOrdinal32WRPoints",
        "getColorCardinalPoints",
        "setColorCardinalPoints",
        "v",
        "getFlagAtmosphere",
        "setFlagAtmosphere",
        "getAtmosphereModel",
        "setAtmosphereModel",
        "getAtmosphereModelPath",
        "setAtmosphereModelPath",
        "getDefaultAtmosphereModelPath",
        "getAtmosphereShowMySkyStoppedWithError",
        "setAtmosphereShowMySkyStoppedWithError",
        "getAtmosphereShowMySkyStatusText",
        "setAtmosphereShowMySkyStatusText",
        "text",
        "getFlagAtmosphereZeroOrderScattering",
        "setFlagAtmosphereZeroOrderScattering",
        "enable",
        "getFlagAtmosphereSingleScattering",
        "setFlagAtmosphereSingleScattering",
        "getFlagAtmosphereMultipleScattering",
        "setFlagAtmosphereMultipleScattering",
        "getFlagAtmospherePseudoMirror",
        "setFlagAtmospherePseudoMirror",
        "getAtmosphereEclipseSimulationQuality",
        "setAtmosphereEclipseSimulationQuality",
        "getFlagAtmosphereNoScatter",
        "setFlagAtmosphereNoScatter",
        "getAtmosphereFadeIntensity",
        "getAtmosphereFadeDuration",
        "setAtmosphereFadeDuration",
        "f",
        "getLandscapeTransparency",
        "setLandscapeTransparency",
        "getFlagLandscapeUseTransparency",
        "setFlagLandscapeUseTransparency",
        "setLandscapeTint",
        "getLandscapeTint",
        "setZRotation",
        "d",
        "installLandscapeFromArchive",
        "pathToSourceArchive",
        "display",
        "forAllUsers",
        "removeLandscape",
        "landscapeID",
        "loadLandscapeName",
        "loadLandscapeSize",
        "getFlagLandscapeAutoSelection",
        "setFlagLandscapeAutoSelection",
        "enableAutoSelect",
        "getFlagEnvironmentAutoEnable",
        "setFlagEnvironmentAutoEnable",
        "getLandscapeOpacity",
        "Vec3d",
        "azalt",
        "azimuth",
        "altitude",
        "showMessage",
        "message",
        "clearMessage",
        "onLocationChanged",
        "StelLocation",
        "loc",
        "onTargetLocationChanged",
        "updateI18n",
        "increaseLightPollution",
        "reduceLightPollution",
        "cyclicChangeLightPollution",
        "createAtmosphere",
        "resetToFallbackAtmosphere",
        "atmosphereDisplayed",
        "atmosphereNoScatter",
        "atmosphereModel",
        "atmosphereModelPath",
        "defaultAtmosphereModelPath",
        "atmosphereShowMySkyStoppedWithError",
        "atmosphereShowMySkyStatusText",
        "flagAtmosphereZeroOrderScattering",
        "flagAtmosphereSingleScattering",
        "flagAtmosphereMultipleScattering",
        "flagAtmospherePseudoMirror",
        "atmosphereEclipseSimulationQuality",
        "cardinalPointsDisplayed",
        "ordinalPointsDisplayed",
        "ordinal16WRPointsDisplayed",
        "ordinal32WRPointsDisplayed",
        "cardinalPointsColor",
        "fogDisplayed",
        "landscapeDisplayed",
        "illuminationDisplayed",
        "labelsDisplayed",
        "flagPolyLineDisplayedOnly",
        "polyLineThickness",
        "polyLineColor",
        "flagUseLightPollutionFromDatabase",
        "flagLandscapeAutoSelection",
        "flagLandscapeSetsLocation",
        "flagLandscapeUseMinimalBrightness",
        "flagLandscapeSetsMinimalBrightness",
        "defaultMinimalBrightness",
        "flagEnvironmentAutoEnabling",
        "allLandscapeNames",
        "currentLandscapeHtmlDescription",
        "defaultLandscapeID",
        "labelFontSize",
        "labelColor",
        "labelAngle",
        "landscapeTransparency",
        "flagLandscapeUseTransparency"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'atmosphereDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'atmosphereModelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'atmosphereModelPathChanged'
        QtMocHelpers::SignalData<void(const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Signal 'atmosphereStoppedWithErrorChanged'
        QtMocHelpers::SignalData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Signal 'atmosphereStatusTextChanged'
        QtMocHelpers::SignalData<void(const QString &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 10 },
        }}),
        // Signal 'flagAtmosphereZeroOrderScatteringChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'flagAtmosphereSingleScatteringChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'flagAtmosphereMultipleScatteringChanged'
        QtMocHelpers::SignalData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'flagAtmospherePseudoMirrorChanged'
        QtMocHelpers::SignalData<void(bool)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'atmosphereEclipseSimulationQualityChanged'
        QtMocHelpers::SignalData<void(unsigned )>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'atmosphereNoScatterChanged'
        QtMocHelpers::SignalData<void(const bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Signal 'cardinalPointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ordinalPointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ordinal16WRPointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'ordinal32WRPointsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'cardinalPointsColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &) const>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 26 },
        }}),
        // Signal 'fogDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'landscapeDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'illuminationDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'labelsDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'labelFontSizeChanged'
        QtMocHelpers::SignalData<void(const int)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 32 },
        }}),
        // Signal 'labelColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 34 },
        }}),
        // Signal 'labelAngleChanged'
        QtMocHelpers::SignalData<void(const int)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 },
        }}),
        // Signal 'flagPolyLineOnlyDisplayedChanged'
        QtMocHelpers::SignalData<void(const bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 38 },
        }}),
        // Signal 'polyLineThicknessChanged'
        QtMocHelpers::SignalData<void(const int)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 40 },
        }}),
        // Signal 'polyLineColorChanged'
        QtMocHelpers::SignalData<void(const Vec3f &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 34 },
        }}),
        // Signal 'flagUseLightPollutionFromDatabaseChanged'
        QtMocHelpers::SignalData<void(const bool)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 43 },
        }}),
        // Signal 'flagLandscapeAutoSelectionChanged'
        QtMocHelpers::SignalData<void(const bool)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'flagLandscapeSetsLocationChanged'
        QtMocHelpers::SignalData<void(const bool)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'flagLandscapeUseMinimalBrightnessChanged'
        QtMocHelpers::SignalData<void(const bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'flagLandscapeSetsMinimalBrightnessChanged'
        QtMocHelpers::SignalData<void(const bool)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'defaultMinimalBrightnessChanged'
        QtMocHelpers::SignalData<void(const double)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 12 },
        }}),
        // Signal 'setFlagEnvironmentAutoEnableChanged'
        QtMocHelpers::SignalData<void(const bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 38 },
        }}),
        // Signal 'landscapeTransparencyChanged'
        QtMocHelpers::SignalData<void(const double)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 12 },
        }}),
        // Signal 'flagLandscapeUseTransparencyChanged'
        QtMocHelpers::SignalData<void(const bool)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'defaultLandscapeChanged'
        QtMocHelpers::SignalData<void(const QString &)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 53 },
        }}),
        // Signal 'landscapesChanged'
        QtMocHelpers::SignalData<void()>(54, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorUnableToOpen'
        QtMocHelpers::SignalData<void(QString)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 56 },
        }}),
        // Signal 'errorNotArchive'
        QtMocHelpers::SignalData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorNotUnique'
        QtMocHelpers::SignalData<void(QString)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 59 },
        }}),
        // Signal 'errorRemoveManually'
        QtMocHelpers::SignalData<void(QString)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 56 },
        }}),
        // Signal 'currentLandscapeChanged'
        QtMocHelpers::SignalData<void(QString, QString)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 62 }, { QMetaType::QString, 63 },
        }}),
        // Slot 'getLuminance'
        QtMocHelpers::SlotData<float() const>(64, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'getAtmosphereAverageLuminance'
        QtMocHelpers::SlotData<float() const>(65, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setAtmosphereAverageLuminance'
        QtMocHelpers::SlotData<void(const float)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 67 },
        }}),
        // Slot 'getNameToDirMap'
        QtMocHelpers::SlotData<QMap<QString,QString>()>(68, 2, QMC::AccessPublic, 0x80000000 | 69),
        // Slot 'getAllLandscapeNames'
        QtMocHelpers::SlotData<QStringList() const>(70, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'getAllLandscapeIDs'
        QtMocHelpers::SlotData<QStringList() const>(71, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'getUserLandscapeIDs'
        QtMocHelpers::SlotData<QStringList() const>(72, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'getCurrentLandscapeID'
        QtMocHelpers::SlotData<const QString() const>(73, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setCurrentLandscapeID'
        QtMocHelpers::SlotData<bool(const QString &, const double)>(74, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 53 }, { QMetaType::Double, 75 },
        }}),
        // Slot 'setCurrentLandscapeID'
        QtMocHelpers::SlotData<bool(const QString &)>(74, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 53 },
        }}),
        // Slot 'getCurrentLandscapeName'
        QtMocHelpers::SlotData<QString() const>(76, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setCurrentLandscapeName'
        QtMocHelpers::SlotData<bool(const QString &, const double)>(77, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 78 }, { QMetaType::Double, 75 },
        }}),
        // Slot 'setCurrentLandscapeName'
        QtMocHelpers::SlotData<bool(const QString &)>(77, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 78 },
        }}),
        // Slot 'getCurrentLandscapeBrightness'
        QtMocHelpers::SlotData<float(const bool) const>(79, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Bool, 80 },
        }}),
        // Slot 'getCurrentLandscapeBrightness'
        QtMocHelpers::SlotData<float() const>(79, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Float),
        // Slot 'precacheLandscape'
        QtMocHelpers::SlotData<bool(const QString &, const bool)>(81, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 53 }, { QMetaType::Bool, 82 },
        }}),
        // Slot 'precacheLandscape'
        QtMocHelpers::SlotData<bool(const QString &)>(81, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 53 },
        }}),
        // Slot 'removeCachedLandscape'
        QtMocHelpers::SlotData<bool(const QString &)>(83, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 53 },
        }}),
        // Slot 'setCacheSize'
        QtMocHelpers::SlotData<void(int)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 85 },
        }}),
        // Slot 'getCacheSize'
        QtMocHelpers::SlotData<int() const>(86, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getCacheFilledSize'
        QtMocHelpers::SlotData<int() const>(87, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getCacheCount'
        QtMocHelpers::SlotData<int() const>(88, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'getCurrentLandscape'
        QtMocHelpers::SlotData<Landscape *() const>(89, 2, QMC::AccessPublic, 0x80000000 | 90),
        // Slot 'getDefaultLandscapeID'
        QtMocHelpers::SlotData<const QString() const>(91, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setDefaultLandscapeID'
        QtMocHelpers::SlotData<bool(const QString &)>(92, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 53 },
        }}),
        // Slot 'getCurrentLandscapeHtmlDescription'
        QtMocHelpers::SlotData<QString() const>(93, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getDescription'
        QtMocHelpers::SlotData<QString() const>(94, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getFlagLandscape'
        QtMocHelpers::SlotData<bool() const>(95, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLandscape'
        QtMocHelpers::SlotData<void(const bool)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getIsLandscapeFullyVisible'
        QtMocHelpers::SlotData<bool() const>(97, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getLandscapeSinMinAltitudeLimit'
        QtMocHelpers::SlotData<double() const>(98, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'getFlagFog'
        QtMocHelpers::SlotData<bool() const>(99, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagFog'
        QtMocHelpers::SlotData<void(const bool)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagIllumination'
        QtMocHelpers::SlotData<bool() const>(101, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagIllumination'
        QtMocHelpers::SlotData<void(const bool)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 103 },
        }}),
        // Slot 'getFlagLabels'
        QtMocHelpers::SlotData<bool() const>(104, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLabels'
        QtMocHelpers::SlotData<void(const bool)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 103 },
        }}),
        // Slot 'getLabelFontSize'
        QtMocHelpers::SlotData<int() const>(106, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLabelFontSize'
        QtMocHelpers::SlotData<void(const int)>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 32 },
        }}),
        // Slot 'getLabelAngle'
        QtMocHelpers::SlotData<int() const>(108, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLabelAngle'
        QtMocHelpers::SlotData<void(const int)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 36 },
        }}),
        // Slot 'getLabelColor'
        QtMocHelpers::SlotData<Vec3f() const>(110, 2, QMC::AccessPublic, 0x80000000 | 25),
        // Slot 'setLabelColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 34 },
        }}),
        // Slot 'getFlagPolyLineOnlyDisplayed'
        QtMocHelpers::SlotData<bool() const>(112, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagPolyLineOnlyDisplayed'
        QtMocHelpers::SlotData<void(bool)>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 114 },
        }}),
        // Slot 'getPolyLineThickness'
        QtMocHelpers::SlotData<int() const>(115, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setPolyLineThickness'
        QtMocHelpers::SlotData<void(int)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 40 },
        }}),
        // Slot 'getPolyLineColor'
        QtMocHelpers::SlotData<Vec3f() const>(117, 2, QMC::AccessPublic, 0x80000000 | 25),
        // Slot 'setPolyLineColor'
        QtMocHelpers::SlotData<void(const Vec3f &)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 34 },
        }}),
        // Slot 'getFlagLandscapeSetsLocation'
        QtMocHelpers::SlotData<bool() const>(119, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLandscapeSetsLocation'
        QtMocHelpers::SlotData<void(bool)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 114 },
        }}),
        // Slot 'getFlagLandscapeUseMinimalBrightness'
        QtMocHelpers::SlotData<bool() const>(121, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLandscapeUseMinimalBrightness'
        QtMocHelpers::SlotData<void(bool)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 114 },
        }}),
        // Slot 'getFlagLandscapeSetsMinimalBrightness'
        QtMocHelpers::SlotData<bool() const>(123, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLandscapeSetsMinimalBrightness'
        QtMocHelpers::SlotData<void(bool)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 114 },
        }}),
        // Slot 'getDefaultMinimalBrightness'
        QtMocHelpers::SlotData<double() const>(125, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setDefaultMinimalBrightness'
        QtMocHelpers::SlotData<void(const double)>(126, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 114 },
        }}),
        // Slot 'setFlagUseLightPollutionFromDatabase'
        QtMocHelpers::SlotData<void(const bool)>(127, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 43 },
        }}),
        // Slot 'getFlagUseLightPollutionFromDatabase'
        QtMocHelpers::SlotData<bool() const>(128, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'getFlagCardinalPoints'
        QtMocHelpers::SlotData<bool() const>(129, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagCardinalPoints'
        QtMocHelpers::SlotData<void(const bool)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagOrdinalPoints'
        QtMocHelpers::SlotData<bool() const>(131, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagOrdinalPoints'
        QtMocHelpers::SlotData<void(const bool)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagOrdinal16WRPoints'
        QtMocHelpers::SlotData<bool() const>(133, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagOrdinal16WRPoints'
        QtMocHelpers::SlotData<void(const bool)>(134, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getFlagOrdinal32WRPoints'
        QtMocHelpers::SlotData<bool() const>(135, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagOrdinal32WRPoints'
        QtMocHelpers::SlotData<void(const bool)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getColorCardinalPoints'
        QtMocHelpers::SlotData<Vec3f() const>(137, 2, QMC::AccessPublic, 0x80000000 | 25),
        // Slot 'setColorCardinalPoints'
        QtMocHelpers::SlotData<void(const Vec3f &)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 139 },
        }}),
        // Slot 'getFlagAtmosphere'
        QtMocHelpers::SlotData<bool() const>(140, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAtmosphere'
        QtMocHelpers::SlotData<void(const bool)>(141, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getAtmosphereModel'
        QtMocHelpers::SlotData<QString() const>(142, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setAtmosphereModel'
        QtMocHelpers::SlotData<void(const QString &)>(143, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 5 },
        }}),
        // Slot 'getAtmosphereModelPath'
        QtMocHelpers::SlotData<QString() const>(144, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setAtmosphereModelPath'
        QtMocHelpers::SlotData<void(const QString &)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 56 },
        }}),
        // Slot 'getDefaultAtmosphereModelPath'
        QtMocHelpers::SlotData<QString() const>(146, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getAtmosphereShowMySkyStoppedWithError'
        QtMocHelpers::SlotData<bool() const>(147, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setAtmosphereShowMySkyStoppedWithError'
        QtMocHelpers::SlotData<void(bool)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Slot 'getAtmosphereShowMySkyStatusText'
        QtMocHelpers::SlotData<QString() const>(149, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setAtmosphereShowMySkyStatusText'
        QtMocHelpers::SlotData<void(const QString &)>(150, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 151 },
        }}),
        // Slot 'getFlagAtmosphereZeroOrderScattering'
        QtMocHelpers::SlotData<bool() const>(152, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAtmosphereZeroOrderScattering'
        QtMocHelpers::SlotData<void(bool)>(153, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getFlagAtmosphereSingleScattering'
        QtMocHelpers::SlotData<bool() const>(155, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAtmosphereSingleScattering'
        QtMocHelpers::SlotData<void(bool)>(156, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getFlagAtmosphereMultipleScattering'
        QtMocHelpers::SlotData<bool() const>(157, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAtmosphereMultipleScattering'
        QtMocHelpers::SlotData<void(bool)>(158, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getFlagAtmospherePseudoMirror'
        QtMocHelpers::SlotData<bool() const>(159, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAtmospherePseudoMirror'
        QtMocHelpers::SlotData<void(bool)>(160, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 154 },
        }}),
        // Slot 'getAtmosphereEclipseSimulationQuality'
        QtMocHelpers::SlotData<int() const>(161, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setAtmosphereEclipseSimulationQuality'
        QtMocHelpers::SlotData<void(int)>(162, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'getFlagAtmosphereNoScatter'
        QtMocHelpers::SlotData<bool() const>(163, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagAtmosphereNoScatter'
        QtMocHelpers::SlotData<void(const bool)>(164, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Slot 'getAtmosphereFadeIntensity'
        QtMocHelpers::SlotData<float() const>(165, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'getAtmosphereFadeDuration'
        QtMocHelpers::SlotData<float() const>(166, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setAtmosphereFadeDuration'
        QtMocHelpers::SlotData<void(const float)>(167, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 168 },
        }}),
        // Slot 'getLandscapeTransparency'
        QtMocHelpers::SlotData<double() const>(169, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setLandscapeTransparency'
        QtMocHelpers::SlotData<void(const double)>(170, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 168 },
        }}),
        // Slot 'getFlagLandscapeUseTransparency'
        QtMocHelpers::SlotData<bool() const>(171, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLandscapeUseTransparency'
        QtMocHelpers::SlotData<void(bool)>(172, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 114 },
        }}),
        // Slot 'setLandscapeTint'
        QtMocHelpers::SlotData<void(const Vec3f &)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 34 },
        }}),
        // Slot 'getLandscapeTint'
        QtMocHelpers::SlotData<Vec3f() const>(174, 2, QMC::AccessPublic, 0x80000000 | 25),
        // Slot 'setZRotation'
        QtMocHelpers::SlotData<void(const float)>(175, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 176 },
        }}),
        // Slot 'installLandscapeFromArchive'
        QtMocHelpers::SlotData<QString(QString, const bool, const bool)>(177, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 178 }, { QMetaType::Bool, 179 }, { QMetaType::Bool, 180 },
        }}),
        // Slot 'installLandscapeFromArchive'
        QtMocHelpers::SlotData<QString(QString, const bool)>(177, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 178 }, { QMetaType::Bool, 179 },
        }}),
        // Slot 'installLandscapeFromArchive'
        QtMocHelpers::SlotData<QString(QString)>(177, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 178 },
        }}),
        // Slot 'removeLandscape'
        QtMocHelpers::SlotData<bool(const QString)>(181, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 182 },
        }}),
        // Slot 'loadLandscapeName'
        QtMocHelpers::SlotData<QString(const QString)>(183, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 182 },
        }}),
        // Slot 'loadLandscapeSize'
        QtMocHelpers::SlotData<quint64(const QString) const>(184, 2, QMC::AccessPublic, QMetaType::ULongLong, {{
            { QMetaType::QString, 182 },
        }}),
        // Slot 'getFlagLandscapeAutoSelection'
        QtMocHelpers::SlotData<bool() const>(185, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagLandscapeAutoSelection'
        QtMocHelpers::SlotData<void(bool)>(186, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 187 },
        }}),
        // Slot 'getFlagEnvironmentAutoEnable'
        QtMocHelpers::SlotData<bool() const>(188, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagEnvironmentAutoEnable'
        QtMocHelpers::SlotData<void(bool)>(189, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 114 },
        }}),
        // Slot 'getLandscapeOpacity'
        QtMocHelpers::SlotData<float(Vec3d) const>(190, 2, QMC::AccessPublic, QMetaType::Float, {{
            { 0x80000000 | 191, 192 },
        }}),
        // Slot 'getLandscapeOpacity'
        QtMocHelpers::SlotData<float(Vec3f) const>(190, 2, QMC::AccessPublic, QMetaType::Float, {{
            { 0x80000000 | 25, 192 },
        }}),
        // Slot 'getLandscapeOpacity'
        QtMocHelpers::SlotData<float(float, float) const>(190, 2, QMC::AccessPublic, QMetaType::Float, {{
            { QMetaType::Float, 193 }, { QMetaType::Float, 194 },
        }}),
        // Slot 'showMessage'
        QtMocHelpers::SlotData<void(const QString &)>(195, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 196 },
        }}),
        // Slot 'clearMessage'
        QtMocHelpers::SlotData<void()>(197, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onLocationChanged'
        QtMocHelpers::SlotData<void(const StelLocation &)>(198, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 199, 200 },
        }}),
        // Slot 'onTargetLocationChanged'
        QtMocHelpers::SlotData<void(const StelLocation &, const QString &)>(201, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 199, 200 }, { QMetaType::QString, 182 },
        }}),
        // Slot 'updateI18n'
        QtMocHelpers::SlotData<void()>(202, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'increaseLightPollution'
        QtMocHelpers::SlotData<void()>(203, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'reduceLightPollution'
        QtMocHelpers::SlotData<void()>(204, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'cyclicChangeLightPollution'
        QtMocHelpers::SlotData<void()>(205, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'createAtmosphere'
        QtMocHelpers::SlotData<void()>(206, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'resetToFallbackAtmosphere'
        QtMocHelpers::SlotData<void()>(207, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'atmosphereDisplayed'
        QtMocHelpers::PropertyData<bool>(208, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 0),
        // property 'atmosphereNoScatter'
        QtMocHelpers::PropertyData<bool>(209, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 10),
        // property 'atmosphereModel'
        QtMocHelpers::PropertyData<QString>(210, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'atmosphereModelPath'
        QtMocHelpers::PropertyData<QString>(211, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'defaultAtmosphereModelPath'
        QtMocHelpers::PropertyData<QString>(212, QMetaType::QString, QMC::Readable | QMC::Designable | QMC::Stored | QMC::Constant),
        // property 'atmosphereShowMySkyStoppedWithError'
        QtMocHelpers::PropertyData<bool>(213, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'atmosphereShowMySkyStatusText'
        QtMocHelpers::PropertyData<QString>(214, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'flagAtmosphereZeroOrderScattering'
        QtMocHelpers::PropertyData<bool>(215, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'flagAtmosphereSingleScattering'
        QtMocHelpers::PropertyData<bool>(216, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'flagAtmosphereMultipleScattering'
        QtMocHelpers::PropertyData<bool>(217, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'flagAtmospherePseudoMirror'
        QtMocHelpers::PropertyData<bool>(218, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'atmosphereEclipseSimulationQuality'
        QtMocHelpers::PropertyData<int>(219, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'cardinalPointsDisplayed'
        QtMocHelpers::PropertyData<bool>(220, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 11),
        // property 'ordinalPointsDisplayed'
        QtMocHelpers::PropertyData<bool>(221, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'ordinal16WRPointsDisplayed'
        QtMocHelpers::PropertyData<bool>(222, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 13),
        // property 'ordinal32WRPointsDisplayed'
        QtMocHelpers::PropertyData<bool>(223, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 14),
        // property 'cardinalPointsColor'
        QtMocHelpers::PropertyData<Vec3f>(224, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 15),
        // property 'fogDisplayed'
        QtMocHelpers::PropertyData<bool>(225, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 16),
        // property 'landscapeDisplayed'
        QtMocHelpers::PropertyData<bool>(226, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 17),
        // property 'illuminationDisplayed'
        QtMocHelpers::PropertyData<bool>(227, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 18),
        // property 'labelsDisplayed'
        QtMocHelpers::PropertyData<bool>(228, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 19),
        // property 'flagPolyLineDisplayedOnly'
        QtMocHelpers::PropertyData<bool>(229, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 23),
        // property 'polyLineThickness'
        QtMocHelpers::PropertyData<int>(230, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'polyLineColor'
        QtMocHelpers::PropertyData<Vec3f>(231, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 25),
        // property 'flagUseLightPollutionFromDatabase'
        QtMocHelpers::PropertyData<bool>(232, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'flagLandscapeAutoSelection'
        QtMocHelpers::PropertyData<bool>(233, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'flagLandscapeSetsLocation'
        QtMocHelpers::PropertyData<bool>(234, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'flagLandscapeUseMinimalBrightness'
        QtMocHelpers::PropertyData<bool>(235, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'flagLandscapeSetsMinimalBrightness'
        QtMocHelpers::PropertyData<bool>(236, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 30),
        // property 'defaultMinimalBrightness'
        QtMocHelpers::PropertyData<double>(237, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 31),
        // property 'flagEnvironmentAutoEnabling'
        QtMocHelpers::PropertyData<bool>(238, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 32),
        // property 'currentLandscapeID'
        QtMocHelpers::PropertyData<QString>(62, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 41),
        // property 'allLandscapeNames'
        QtMocHelpers::PropertyData<QStringList>(239, QMetaType::QStringList, QMC::DefaultPropertyFlags, 36),
        // property 'currentLandscapeName'
        QtMocHelpers::PropertyData<QString>(63, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 41),
        // property 'currentLandscapeHtmlDescription'
        QtMocHelpers::PropertyData<QString>(240, QMetaType::QString, QMC::DefaultPropertyFlags, 41),
        // property 'defaultLandscapeID'
        QtMocHelpers::PropertyData<QString>(241, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 35),
        // property 'labelFontSize'
        QtMocHelpers::PropertyData<int>(242, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'labelColor'
        QtMocHelpers::PropertyData<Vec3f>(243, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 21),
        // property 'labelAngle'
        QtMocHelpers::PropertyData<int>(244, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'landscapeTransparency'
        QtMocHelpers::PropertyData<double>(245, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 33),
        // property 'flagLandscapeUseTransparency'
        QtMocHelpers::PropertyData<bool>(246, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 34),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LandscapeMgr, qt_meta_tag_ZN12LandscapeMgrE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LandscapeMgr::staticMetaObject = { {
    QMetaObject::SuperData::link<StelModule::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12LandscapeMgrE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12LandscapeMgrE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12LandscapeMgrE_t>.metaTypes,
    nullptr
} };

void LandscapeMgr::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<LandscapeMgr *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->atmosphereDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->atmosphereModelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->atmosphereModelPathChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->atmosphereStoppedWithErrorChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 4: _t->atmosphereStatusTextChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->flagAtmosphereZeroOrderScatteringChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->flagAtmosphereSingleScatteringChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->flagAtmosphereMultipleScatteringChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->flagAtmospherePseudoMirrorChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->atmosphereEclipseSimulationQualityChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 10: _t->atmosphereNoScatterChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->cardinalPointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->ordinalPointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->ordinal16WRPointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->ordinal32WRPointsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->cardinalPointsColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 16: _t->fogDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->landscapeDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->illuminationDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->labelsDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->labelFontSizeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 21: _t->labelColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 22: _t->labelAngleChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 23: _t->flagPolyLineOnlyDisplayedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->polyLineThicknessChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 25: _t->polyLineColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 26: _t->flagUseLightPollutionFromDatabaseChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->flagLandscapeAutoSelectionChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 28: _t->flagLandscapeSetsLocationChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->flagLandscapeUseMinimalBrightnessChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->flagLandscapeSetsMinimalBrightnessChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: _t->defaultMinimalBrightnessChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 32: _t->setFlagEnvironmentAutoEnableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->landscapeTransparencyChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 34: _t->flagLandscapeUseTransparencyChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->defaultLandscapeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 36: _t->landscapesChanged(); break;
        case 37: _t->errorUnableToOpen((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 38: _t->errorNotArchive(); break;
        case 39: _t->errorNotUnique((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 40: _t->errorRemoveManually((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 41: _t->currentLandscapeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 42: { float _r = _t->getLuminance();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 43: { float _r = _t->getAtmosphereAverageLuminance();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 44: _t->setAtmosphereAverageLuminance((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 45: { QMap<QString,QString> _r = _t->getNameToDirMap();
            if (_a[0]) *reinterpret_cast<QMap<QString,QString>*>(_a[0]) = std::move(_r); }  break;
        case 46: { QStringList _r = _t->getAllLandscapeNames();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 47: { QStringList _r = _t->getAllLandscapeIDs();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 48: { QStringList _r = _t->getUserLandscapeIDs();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 49: { QString _r = _t->getCurrentLandscapeID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 50: { bool _r = _t->setCurrentLandscapeID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 51: { bool _r = _t->setCurrentLandscapeID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 52: { QString _r = _t->getCurrentLandscapeName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 53: { bool _r = _t->setCurrentLandscapeName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 54: { bool _r = _t->setCurrentLandscapeName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 55: { float _r = _t->getCurrentLandscapeBrightness((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 56: { float _r = _t->getCurrentLandscapeBrightness();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 57: { bool _r = _t->precacheLandscape((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 58: { bool _r = _t->precacheLandscape((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 59: { bool _r = _t->removeCachedLandscape((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 60: _t->setCacheSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 61: { int _r = _t->getCacheSize();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 62: { int _r = _t->getCacheFilledSize();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 63: { int _r = _t->getCacheCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 64: { Landscape* _r = _t->getCurrentLandscape();
            if (_a[0]) *reinterpret_cast<Landscape**>(_a[0]) = std::move(_r); }  break;
        case 65: { QString _r = _t->getDefaultLandscapeID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 66: { bool _r = _t->setDefaultLandscapeID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 67: { QString _r = _t->getCurrentLandscapeHtmlDescription();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 68: { QString _r = _t->getDescription();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 69: { bool _r = _t->getFlagLandscape();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 70: _t->setFlagLandscape((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 71: { bool _r = _t->getIsLandscapeFullyVisible();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 72: { double _r = _t->getLandscapeSinMinAltitudeLimit();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 73: { bool _r = _t->getFlagFog();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 74: _t->setFlagFog((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 75: { bool _r = _t->getFlagIllumination();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 76: _t->setFlagIllumination((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 77: { bool _r = _t->getFlagLabels();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 78: _t->setFlagLabels((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 79: { int _r = _t->getLabelFontSize();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 80: _t->setLabelFontSize((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 81: { int _r = _t->getLabelAngle();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 82: _t->setLabelAngle((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 83: { Vec3f _r = _t->getLabelColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 84: _t->setLabelColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 85: { bool _r = _t->getFlagPolyLineOnlyDisplayed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 86: _t->setFlagPolyLineOnlyDisplayed((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 87: { int _r = _t->getPolyLineThickness();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 88: _t->setPolyLineThickness((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 89: { Vec3f _r = _t->getPolyLineColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 90: _t->setPolyLineColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 91: { bool _r = _t->getFlagLandscapeSetsLocation();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 92: _t->setFlagLandscapeSetsLocation((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 93: { bool _r = _t->getFlagLandscapeUseMinimalBrightness();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 94: _t->setFlagLandscapeUseMinimalBrightness((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 95: { bool _r = _t->getFlagLandscapeSetsMinimalBrightness();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 96: _t->setFlagLandscapeSetsMinimalBrightness((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 97: { double _r = _t->getDefaultMinimalBrightness();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 98: _t->setDefaultMinimalBrightness((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 99: _t->setFlagUseLightPollutionFromDatabase((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 100: { bool _r = _t->getFlagUseLightPollutionFromDatabase();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 101: { bool _r = _t->getFlagCardinalPoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 102: _t->setFlagCardinalPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 103: { bool _r = _t->getFlagOrdinalPoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 104: _t->setFlagOrdinalPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 105: { bool _r = _t->getFlagOrdinal16WRPoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 106: _t->setFlagOrdinal16WRPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 107: { bool _r = _t->getFlagOrdinal32WRPoints();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 108: _t->setFlagOrdinal32WRPoints((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 109: { Vec3f _r = _t->getColorCardinalPoints();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 110: _t->setColorCardinalPoints((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 111: { bool _r = _t->getFlagAtmosphere();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 112: _t->setFlagAtmosphere((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 113: { QString _r = _t->getAtmosphereModel();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 114: _t->setAtmosphereModel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 115: { QString _r = _t->getAtmosphereModelPath();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 116: _t->setAtmosphereModelPath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 117: { QString _r = _t->getDefaultAtmosphereModelPath();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 118: { bool _r = _t->getAtmosphereShowMySkyStoppedWithError();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 119: _t->setAtmosphereShowMySkyStoppedWithError((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 120: { QString _r = _t->getAtmosphereShowMySkyStatusText();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 121: _t->setAtmosphereShowMySkyStatusText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 122: { bool _r = _t->getFlagAtmosphereZeroOrderScattering();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 123: _t->setFlagAtmosphereZeroOrderScattering((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 124: { bool _r = _t->getFlagAtmosphereSingleScattering();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 125: _t->setFlagAtmosphereSingleScattering((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 126: { bool _r = _t->getFlagAtmosphereMultipleScattering();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 127: _t->setFlagAtmosphereMultipleScattering((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 128: { bool _r = _t->getFlagAtmospherePseudoMirror();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 129: _t->setFlagAtmospherePseudoMirror((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 130: { int _r = _t->getAtmosphereEclipseSimulationQuality();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 131: _t->setAtmosphereEclipseSimulationQuality((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 132: { bool _r = _t->getFlagAtmosphereNoScatter();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 133: _t->setFlagAtmosphereNoScatter((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 134: { float _r = _t->getAtmosphereFadeIntensity();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 135: { float _r = _t->getAtmosphereFadeDuration();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 136: _t->setAtmosphereFadeDuration((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 137: { double _r = _t->getLandscapeTransparency();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 138: _t->setLandscapeTransparency((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 139: { bool _r = _t->getFlagLandscapeUseTransparency();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 140: _t->setFlagLandscapeUseTransparency((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 141: _t->setLandscapeTint((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 142: { Vec3f _r = _t->getLandscapeTint();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 143: _t->setZRotation((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 144: { QString _r = _t->installLandscapeFromArchive((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 145: { QString _r = _t->installLandscapeFromArchive((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 146: { QString _r = _t->installLandscapeFromArchive((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 147: { bool _r = _t->removeLandscape((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 148: { QString _r = _t->loadLandscapeName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 149: { quint64 _r = _t->loadLandscapeSize((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<quint64*>(_a[0]) = std::move(_r); }  break;
        case 150: { bool _r = _t->getFlagLandscapeAutoSelection();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 151: _t->setFlagLandscapeAutoSelection((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 152: { bool _r = _t->getFlagEnvironmentAutoEnable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 153: _t->setFlagEnvironmentAutoEnable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 154: { float _r = _t->getLandscapeOpacity((*reinterpret_cast<std::add_pointer_t<Vec3d>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 155: { float _r = _t->getLandscapeOpacity((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 156: { float _r = _t->getLandscapeOpacity((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2])));
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 157: _t->showMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 158: _t->clearMessage(); break;
        case 159: _t->onLocationChanged((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1]))); break;
        case 160: _t->onTargetLocationChanged((*reinterpret_cast<std::add_pointer_t<StelLocation>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 161: _t->updateI18n(); break;
        case 162: _t->increaseLightPollution(); break;
        case 163: _t->reduceLightPollution(); break;
        case 164: _t->cyclicChangeLightPollution(); break;
        case 165: _t->createAtmosphere(); break;
        case 166: _t->resetToFallbackAtmosphere(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); 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 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 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 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 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 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 141:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 154:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3d >(); break;
            }
            break;
        case 155:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 159:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        case 160:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< StelLocation >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::atmosphereDisplayedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const QString & )>(_a, &LandscapeMgr::atmosphereModelChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const QString & )>(_a, &LandscapeMgr::atmosphereModelPathChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(bool )>(_a, &LandscapeMgr::atmosphereStoppedWithErrorChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const QString & )>(_a, &LandscapeMgr::atmosphereStatusTextChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(bool )>(_a, &LandscapeMgr::flagAtmosphereZeroOrderScatteringChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(bool )>(_a, &LandscapeMgr::flagAtmosphereSingleScatteringChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(bool )>(_a, &LandscapeMgr::flagAtmosphereMultipleScatteringChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(bool )>(_a, &LandscapeMgr::flagAtmospherePseudoMirrorChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(unsigned  )>(_a, &LandscapeMgr::atmosphereEclipseSimulationQualityChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::atmosphereNoScatterChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::cardinalPointsDisplayedChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::ordinalPointsDisplayedChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::ordinal16WRPointsDisplayedChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::ordinal32WRPointsDisplayedChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const Vec3f & ) const>(_a, &LandscapeMgr::cardinalPointsColorChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::fogDisplayedChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::landscapeDisplayedChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::illuminationDisplayedChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::labelsDisplayedChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const int )>(_a, &LandscapeMgr::labelFontSizeChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const Vec3f & )>(_a, &LandscapeMgr::labelColorChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const int )>(_a, &LandscapeMgr::labelAngleChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagPolyLineOnlyDisplayedChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const int )>(_a, &LandscapeMgr::polyLineThicknessChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const Vec3f & )>(_a, &LandscapeMgr::polyLineColorChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagUseLightPollutionFromDatabaseChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagLandscapeAutoSelectionChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagLandscapeSetsLocationChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagLandscapeUseMinimalBrightnessChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagLandscapeSetsMinimalBrightnessChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const double )>(_a, &LandscapeMgr::defaultMinimalBrightnessChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::setFlagEnvironmentAutoEnableChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const double )>(_a, &LandscapeMgr::landscapeTransparencyChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const bool )>(_a, &LandscapeMgr::flagLandscapeUseTransparencyChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(const QString & )>(_a, &LandscapeMgr::defaultLandscapeChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)()>(_a, &LandscapeMgr::landscapesChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(QString )>(_a, &LandscapeMgr::errorUnableToOpen, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)()>(_a, &LandscapeMgr::errorNotArchive, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(QString )>(_a, &LandscapeMgr::errorNotUnique, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(QString )>(_a, &LandscapeMgr::errorRemoveManually, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (LandscapeMgr::*)(QString , QString )>(_a, &LandscapeMgr::currentLandscapeChanged, 41))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 37:
        case 23:
        case 16:
            *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->getFlagAtmosphere(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlagAtmosphereNoScatter(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->getAtmosphereModel(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->getAtmosphereModelPath(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->getDefaultAtmosphereModelPath(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->getAtmosphereShowMySkyStoppedWithError(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->getAtmosphereShowMySkyStatusText(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->getFlagAtmosphereZeroOrderScattering(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->getFlagAtmosphereSingleScattering(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->getFlagAtmosphereMultipleScattering(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->getFlagAtmospherePseudoMirror(); break;
        case 11: *reinterpret_cast<int*>(_v) = _t->getAtmosphereEclipseSimulationQuality(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->getFlagCardinalPoints(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->getFlagOrdinalPoints(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->getFlagOrdinal16WRPoints(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->getFlagOrdinal32WRPoints(); break;
        case 16: *reinterpret_cast<Vec3f*>(_v) = _t->getColorCardinalPoints(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->getFlagFog(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->getFlagLandscape(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->getFlagIllumination(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->getFlagLabels(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->getFlagPolyLineOnlyDisplayed(); break;
        case 22: *reinterpret_cast<int*>(_v) = _t->getPolyLineThickness(); break;
        case 23: *reinterpret_cast<Vec3f*>(_v) = _t->getPolyLineColor(); break;
        case 24: *reinterpret_cast<bool*>(_v) = _t->getFlagUseLightPollutionFromDatabase(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->getFlagLandscapeAutoSelection(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->getFlagLandscapeSetsLocation(); break;
        case 27: *reinterpret_cast<bool*>(_v) = _t->getFlagLandscapeUseMinimalBrightness(); break;
        case 28: *reinterpret_cast<bool*>(_v) = _t->getFlagLandscapeSetsMinimalBrightness(); break;
        case 29: *reinterpret_cast<double*>(_v) = _t->getDefaultMinimalBrightness(); break;
        case 30: *reinterpret_cast<bool*>(_v) = _t->getFlagEnvironmentAutoEnable(); break;
        case 31: *reinterpret_cast<QString*>(_v) = _t->getCurrentLandscapeID(); break;
        case 32: *reinterpret_cast<QStringList*>(_v) = _t->getAllLandscapeNames(); break;
        case 33: *reinterpret_cast<QString*>(_v) = _t->getCurrentLandscapeName(); break;
        case 34: *reinterpret_cast<QString*>(_v) = _t->getCurrentLandscapeHtmlDescription(); break;
        case 35: *reinterpret_cast<QString*>(_v) = _t->getDefaultLandscapeID(); break;
        case 36: *reinterpret_cast<int*>(_v) = _t->getLabelFontSize(); break;
        case 37: *reinterpret_cast<Vec3f*>(_v) = _t->getLabelColor(); break;
        case 38: *reinterpret_cast<int*>(_v) = _t->getLabelAngle(); break;
        case 39: *reinterpret_cast<double*>(_v) = _t->getLandscapeTransparency(); break;
        case 40: *reinterpret_cast<bool*>(_v) = _t->getFlagLandscapeUseTransparency(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagAtmosphere(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlagAtmosphereNoScatter(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setAtmosphereModel(*reinterpret_cast<QString*>(_v)); break;
        case 3: _t->setAtmosphereModelPath(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setAtmosphereShowMySkyStoppedWithError(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setAtmosphereShowMySkyStatusText(*reinterpret_cast<QString*>(_v)); break;
        case 7: _t->setFlagAtmosphereZeroOrderScattering(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setFlagAtmosphereSingleScattering(*reinterpret_cast<bool*>(_v)); break;
        case 9: _t->setFlagAtmosphereMultipleScattering(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setFlagAtmospherePseudoMirror(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setAtmosphereEclipseSimulationQuality(*reinterpret_cast<int*>(_v)); break;
        case 12: _t->setFlagCardinalPoints(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->setFlagOrdinalPoints(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setFlagOrdinal16WRPoints(*reinterpret_cast<bool*>(_v)); break;
        case 15: _t->setFlagOrdinal32WRPoints(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setColorCardinalPoints(*reinterpret_cast<Vec3f*>(_v)); break;
        case 17: _t->setFlagFog(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setFlagLandscape(*reinterpret_cast<bool*>(_v)); break;
        case 19: _t->setFlagIllumination(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setFlagLabels(*reinterpret_cast<bool*>(_v)); break;
        case 21: _t->setFlagPolyLineOnlyDisplayed(*reinterpret_cast<bool*>(_v)); break;
        case 22: _t->setPolyLineThickness(*reinterpret_cast<int*>(_v)); break;
        case 23: _t->setPolyLineColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 24: _t->setFlagUseLightPollutionFromDatabase(*reinterpret_cast<bool*>(_v)); break;
        case 25: _t->setFlagLandscapeAutoSelection(*reinterpret_cast<bool*>(_v)); break;
        case 26: _t->setFlagLandscapeSetsLocation(*reinterpret_cast<bool*>(_v)); break;
        case 27: _t->setFlagLandscapeUseMinimalBrightness(*reinterpret_cast<bool*>(_v)); break;
        case 28: _t->setFlagLandscapeSetsMinimalBrightness(*reinterpret_cast<bool*>(_v)); break;
        case 29: _t->setDefaultMinimalBrightness(*reinterpret_cast<double*>(_v)); break;
        case 30: _t->setFlagEnvironmentAutoEnable(*reinterpret_cast<bool*>(_v)); break;
        case 31: _t->setCurrentLandscapeID(*reinterpret_cast<QString*>(_v)); break;
        case 33: _t->setCurrentLandscapeName(*reinterpret_cast<QString*>(_v)); break;
        case 35: _t->setDefaultLandscapeID(*reinterpret_cast<QString*>(_v)); break;
        case 36: _t->setLabelFontSize(*reinterpret_cast<int*>(_v)); break;
        case 37: _t->setLabelColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 38: _t->setLabelAngle(*reinterpret_cast<int*>(_v)); break;
        case 39: _t->setLandscapeTransparency(*reinterpret_cast<double*>(_v)); break;
        case 40: _t->setFlagLandscapeUseTransparency(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

// SIGNAL 1
void LandscapeMgr::atmosphereModelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

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

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

// SIGNAL 4
void LandscapeMgr::atmosphereStatusTextChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

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

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

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

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

// SIGNAL 9
void LandscapeMgr::atmosphereEclipseSimulationQualityChanged(unsigned  _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

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

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

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

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

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

// SIGNAL 15
void LandscapeMgr::cardinalPointsColorChanged(const Vec3f & _t1)const
{
    QMetaObject::activate<void>(const_cast< LandscapeMgr *>(this), &staticMetaObject, 15, nullptr, _t1);
}

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

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

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

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

// SIGNAL 20
void LandscapeMgr::labelFontSizeChanged(const int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void LandscapeMgr::labelColorChanged(const Vec3f & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void LandscapeMgr::labelAngleChanged(const int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

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

// SIGNAL 24
void LandscapeMgr::polyLineThicknessChanged(const int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

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

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

// SIGNAL 27
void LandscapeMgr::flagLandscapeAutoSelectionChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

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

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

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

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

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

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

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

// SIGNAL 35
void LandscapeMgr::defaultLandscapeChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void LandscapeMgr::landscapesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}

// SIGNAL 37
void LandscapeMgr::errorUnableToOpen(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void LandscapeMgr::errorNotArchive()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void LandscapeMgr::errorNotUnique(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void LandscapeMgr::errorRemoveManually(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void LandscapeMgr::currentLandscapeChanged(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1, _t2);
}
QT_WARNING_POP
