/****************************************************************************
** Meta object code from reading C++ file 'LandscapeMgr.hpp'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.6.2)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "../../src/stellarium-0.14.3/src/core/modules/LandscapeMgr.hpp"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'LandscapeMgr.hpp' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.6.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_LandscapeMgr_t {
    QByteArrayData data[101];
    char stringdata0[1926];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_LandscapeMgr_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_LandscapeMgr_t qt_meta_stringdata_LandscapeMgr = {
    {
QT_MOC_LITERAL(0, 0, 12), // "LandscapeMgr"
QT_MOC_LITERAL(1, 13, 26), // "atmosphereDisplayedChanged"
QT_MOC_LITERAL(2, 40, 0), // ""
QT_MOC_LITERAL(3, 41, 9), // "displayed"
QT_MOC_LITERAL(4, 51, 31), // "cardinalsPointsDisplayedChanged"
QT_MOC_LITERAL(5, 83, 19), // "fogDisplayedChanged"
QT_MOC_LITERAL(6, 103, 25), // "landscapeDisplayedChanged"
QT_MOC_LITERAL(7, 129, 28), // "illuminationDisplayedChanged"
QT_MOC_LITERAL(8, 158, 22), // "labelsDisplayedChanged"
QT_MOC_LITERAL(9, 181, 26), // "lightPollutionUsageChanged"
QT_MOC_LITERAL(10, 208, 5), // "usage"
QT_MOC_LITERAL(11, 214, 17), // "landscapesChanged"
QT_MOC_LITERAL(12, 232, 21), // "lightPollutionChanged"
QT_MOC_LITERAL(13, 254, 17), // "errorUnableToOpen"
QT_MOC_LITERAL(14, 272, 4), // "path"
QT_MOC_LITERAL(15, 277, 15), // "errorNotArchive"
QT_MOC_LITERAL(16, 293, 14), // "errorNotUnique"
QT_MOC_LITERAL(17, 308, 8), // "nameOrID"
QT_MOC_LITERAL(18, 317, 19), // "errorRemoveManually"
QT_MOC_LITERAL(19, 337, 20), // "getAllLandscapeNames"
QT_MOC_LITERAL(20, 358, 18), // "getAllLandscapeIDs"
QT_MOC_LITERAL(21, 377, 19), // "getUserLandscapeIDs"
QT_MOC_LITERAL(22, 397, 21), // "getCurrentLandscapeID"
QT_MOC_LITERAL(23, 419, 21), // "setCurrentLandscapeID"
QT_MOC_LITERAL(24, 441, 2), // "id"
QT_MOC_LITERAL(25, 444, 22), // "changeLocationDuration"
QT_MOC_LITERAL(26, 467, 23), // "getCurrentLandscapeName"
QT_MOC_LITERAL(27, 491, 23), // "setCurrentLandscapeName"
QT_MOC_LITERAL(28, 515, 4), // "name"
QT_MOC_LITERAL(29, 520, 19), // "getCurrentLandscape"
QT_MOC_LITERAL(30, 540, 10), // "Landscape*"
QT_MOC_LITERAL(31, 551, 21), // "getDefaultLandscapeID"
QT_MOC_LITERAL(32, 573, 21), // "setDefaultLandscapeID"
QT_MOC_LITERAL(33, 595, 34), // "getCurrentLandscapeHtmlDescri..."
QT_MOC_LITERAL(34, 630, 14), // "getDescription"
QT_MOC_LITERAL(35, 645, 16), // "getFlagLandscape"
QT_MOC_LITERAL(36, 662, 16), // "setFlagLandscape"
QT_MOC_LITERAL(37, 679, 26), // "getIsLandscapeFullyVisible"
QT_MOC_LITERAL(38, 706, 31), // "getLandscapeSinMinAltitudeLimit"
QT_MOC_LITERAL(39, 738, 10), // "getFlagFog"
QT_MOC_LITERAL(40, 749, 10), // "setFlagFog"
QT_MOC_LITERAL(41, 760, 19), // "getFlagIllumination"
QT_MOC_LITERAL(42, 780, 19), // "setFlagIllumination"
QT_MOC_LITERAL(43, 800, 2), // "on"
QT_MOC_LITERAL(44, 803, 13), // "getFlagLabels"
QT_MOC_LITERAL(45, 817, 13), // "setFlagLabels"
QT_MOC_LITERAL(46, 831, 28), // "getFlagLandscapeSetsLocation"
QT_MOC_LITERAL(47, 860, 28), // "setFlagLandscapeSetsLocation"
QT_MOC_LITERAL(48, 889, 1), // "b"
QT_MOC_LITERAL(49, 891, 36), // "getFlagLandscapeUseMinimalBri..."
QT_MOC_LITERAL(50, 928, 36), // "setFlagLandscapeUseMinimalBri..."
QT_MOC_LITERAL(51, 965, 37), // "getFlagLandscapeSetsMinimalBr..."
QT_MOC_LITERAL(52, 1003, 37), // "setFlagLandscapeSetsMinimalBr..."
QT_MOC_LITERAL(53, 1041, 27), // "getDefaultMinimalBrightness"
QT_MOC_LITERAL(54, 1069, 27), // "setDefaultMinimalBrightness"
QT_MOC_LITERAL(55, 1097, 36), // "setFlagUseLightPollutionFromD..."
QT_MOC_LITERAL(56, 1134, 36), // "getFlagUseLightPollutionFromD..."
QT_MOC_LITERAL(57, 1171, 22), // "getFlagCardinalsPoints"
QT_MOC_LITERAL(58, 1194, 22), // "setFlagCardinalsPoints"
QT_MOC_LITERAL(59, 1217, 22), // "getColorCardinalPoints"
QT_MOC_LITERAL(60, 1240, 5), // "Vec3f"
QT_MOC_LITERAL(61, 1246, 22), // "setColorCardinalPoints"
QT_MOC_LITERAL(62, 1269, 1), // "v"
QT_MOC_LITERAL(63, 1271, 17), // "getFlagAtmosphere"
QT_MOC_LITERAL(64, 1289, 17), // "setFlagAtmosphere"
QT_MOC_LITERAL(65, 1307, 25), // "getAtmosphereFadeDuration"
QT_MOC_LITERAL(66, 1333, 25), // "setAtmosphereFadeDuration"
QT_MOC_LITERAL(67, 1359, 1), // "f"
QT_MOC_LITERAL(68, 1361, 33), // "setAtmosphereBortleLightPollu..."
QT_MOC_LITERAL(69, 1395, 6), // "bIndex"
QT_MOC_LITERAL(70, 1402, 33), // "getAtmosphereBortleLightPollu..."
QT_MOC_LITERAL(71, 1436, 12), // "setZRotation"
QT_MOC_LITERAL(72, 1449, 1), // "d"
QT_MOC_LITERAL(73, 1451, 27), // "installLandscapeFromArchive"
QT_MOC_LITERAL(74, 1479, 19), // "pathToSourceArchive"
QT_MOC_LITERAL(75, 1499, 7), // "display"
QT_MOC_LITERAL(76, 1507, 11), // "forAllUsers"
QT_MOC_LITERAL(77, 1519, 15), // "removeLandscape"
QT_MOC_LITERAL(78, 1535, 11), // "landscapeID"
QT_MOC_LITERAL(79, 1547, 17), // "loadLandscapeName"
QT_MOC_LITERAL(80, 1565, 17), // "loadLandscapeSize"
QT_MOC_LITERAL(81, 1583, 29), // "getFlagLandscapeAutoSelection"
QT_MOC_LITERAL(82, 1613, 29), // "setFlagLandscapeAutoSelection"
QT_MOC_LITERAL(83, 1643, 16), // "enableAutoSelect"
QT_MOC_LITERAL(84, 1660, 27), // "getFlagAtmosphereAutoEnable"
QT_MOC_LITERAL(85, 1688, 27), // "setFlagAtmosphereAutoEnable"
QT_MOC_LITERAL(86, 1716, 19), // "getLandscapeOpacity"
QT_MOC_LITERAL(87, 1736, 5), // "Vec3d"
QT_MOC_LITERAL(88, 1742, 5), // "azalt"
QT_MOC_LITERAL(89, 1748, 7), // "azimuth"
QT_MOC_LITERAL(90, 1756, 8), // "altitude"
QT_MOC_LITERAL(91, 1765, 12), // "setStelStyle"
QT_MOC_LITERAL(92, 1778, 7), // "section"
QT_MOC_LITERAL(93, 1786, 10), // "updateI18n"
QT_MOC_LITERAL(94, 1797, 19), // "atmosphereDisplayed"
QT_MOC_LITERAL(95, 1817, 24), // "cardinalsPointsDisplayed"
QT_MOC_LITERAL(96, 1842, 12), // "fogDisplayed"
QT_MOC_LITERAL(97, 1855, 18), // "landscapeDisplayed"
QT_MOC_LITERAL(98, 1874, 21), // "illuminationDisplayed"
QT_MOC_LITERAL(99, 1896, 15), // "labelsDisplayed"
QT_MOC_LITERAL(100, 1912, 13) // "databaseUsage"

    },
    "LandscapeMgr\0atmosphereDisplayedChanged\0"
    "\0displayed\0cardinalsPointsDisplayedChanged\0"
    "fogDisplayedChanged\0landscapeDisplayedChanged\0"
    "illuminationDisplayedChanged\0"
    "labelsDisplayedChanged\0"
    "lightPollutionUsageChanged\0usage\0"
    "landscapesChanged\0lightPollutionChanged\0"
    "errorUnableToOpen\0path\0errorNotArchive\0"
    "errorNotUnique\0nameOrID\0errorRemoveManually\0"
    "getAllLandscapeNames\0getAllLandscapeIDs\0"
    "getUserLandscapeIDs\0getCurrentLandscapeID\0"
    "setCurrentLandscapeID\0id\0"
    "changeLocationDuration\0getCurrentLandscapeName\0"
    "setCurrentLandscapeName\0name\0"
    "getCurrentLandscape\0Landscape*\0"
    "getDefaultLandscapeID\0setDefaultLandscapeID\0"
    "getCurrentLandscapeHtmlDescription\0"
    "getDescription\0getFlagLandscape\0"
    "setFlagLandscape\0getIsLandscapeFullyVisible\0"
    "getLandscapeSinMinAltitudeLimit\0"
    "getFlagFog\0setFlagFog\0getFlagIllumination\0"
    "setFlagIllumination\0on\0getFlagLabels\0"
    "setFlagLabels\0getFlagLandscapeSetsLocation\0"
    "setFlagLandscapeSetsLocation\0b\0"
    "getFlagLandscapeUseMinimalBrightness\0"
    "setFlagLandscapeUseMinimalBrightness\0"
    "getFlagLandscapeSetsMinimalBrightness\0"
    "setFlagLandscapeSetsMinimalBrightness\0"
    "getDefaultMinimalBrightness\0"
    "setDefaultMinimalBrightness\0"
    "setFlagUseLightPollutionFromDatabase\0"
    "getFlagUseLightPollutionFromDatabase\0"
    "getFlagCardinalsPoints\0setFlagCardinalsPoints\0"
    "getColorCardinalPoints\0Vec3f\0"
    "setColorCardinalPoints\0v\0getFlagAtmosphere\0"
    "setFlagAtmosphere\0getAtmosphereFadeDuration\0"
    "setAtmosphereFadeDuration\0f\0"
    "setAtmosphereBortleLightPollution\0"
    "bIndex\0getAtmosphereBortleLightPollution\0"
    "setZRotation\0d\0installLandscapeFromArchive\0"
    "pathToSourceArchive\0display\0forAllUsers\0"
    "removeLandscape\0landscapeID\0"
    "loadLandscapeName\0loadLandscapeSize\0"
    "getFlagLandscapeAutoSelection\0"
    "setFlagLandscapeAutoSelection\0"
    "enableAutoSelect\0getFlagAtmosphereAutoEnable\0"
    "setFlagAtmosphereAutoEnable\0"
    "getLandscapeOpacity\0Vec3d\0azalt\0azimuth\0"
    "altitude\0setStelStyle\0section\0updateI18n\0"
    "atmosphereDisplayed\0cardinalsPointsDisplayed\0"
    "fogDisplayed\0landscapeDisplayed\0"
    "illuminationDisplayed\0labelsDisplayed\0"
    "databaseUsage"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_LandscapeMgr[] = {

 // content:
       7,       // revision
       0,       // classname
       0,    0, // classinfo
      72,   14, // methods
       7,  540, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
      13,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,  374,    2, 0x06 /* Public */,
       4,    1,  377,    2, 0x06 /* Public */,
       5,    1,  380,    2, 0x06 /* Public */,
       6,    1,  383,    2, 0x06 /* Public */,
       7,    1,  386,    2, 0x06 /* Public */,
       8,    1,  389,    2, 0x06 /* Public */,
       9,    1,  392,    2, 0x06 /* Public */,
      11,    0,  395,    2, 0x06 /* Public */,
      12,    0,  396,    2, 0x06 /* Public */,
      13,    1,  397,    2, 0x06 /* Public */,
      15,    0,  400,    2, 0x06 /* Public */,
      16,    1,  401,    2, 0x06 /* Public */,
      18,    1,  404,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      19,    0,  407,    2, 0x0a /* Public */,
      20,    0,  408,    2, 0x0a /* Public */,
      21,    0,  409,    2, 0x0a /* Public */,
      22,    0,  410,    2, 0x0a /* Public */,
      23,    2,  411,    2, 0x0a /* Public */,
      23,    1,  416,    2, 0x2a /* Public | MethodCloned */,
      26,    0,  419,    2, 0x0a /* Public */,
      27,    2,  420,    2, 0x0a /* Public */,
      27,    1,  425,    2, 0x2a /* Public | MethodCloned */,
      29,    0,  428,    2, 0x0a /* Public */,
      31,    0,  429,    2, 0x0a /* Public */,
      32,    1,  430,    2, 0x0a /* Public */,
      33,    0,  433,    2, 0x0a /* Public */,
      34,    0,  434,    2, 0x0a /* Public */,
      35,    0,  435,    2, 0x0a /* Public */,
      36,    1,  436,    2, 0x0a /* Public */,
      37,    0,  439,    2, 0x0a /* Public */,
      38,    0,  440,    2, 0x0a /* Public */,
      39,    0,  441,    2, 0x0a /* Public */,
      40,    1,  442,    2, 0x0a /* Public */,
      41,    0,  445,    2, 0x0a /* Public */,
      42,    1,  446,    2, 0x0a /* Public */,
      44,    0,  449,    2, 0x0a /* Public */,
      45,    1,  450,    2, 0x0a /* Public */,
      46,    0,  453,    2, 0x0a /* Public */,
      47,    1,  454,    2, 0x0a /* Public */,
      49,    0,  457,    2, 0x0a /* Public */,
      50,    1,  458,    2, 0x0a /* Public */,
      51,    0,  461,    2, 0x0a /* Public */,
      52,    1,  462,    2, 0x0a /* Public */,
      53,    0,  465,    2, 0x0a /* Public */,
      54,    1,  466,    2, 0x0a /* Public */,
      55,    1,  469,    2, 0x0a /* Public */,
      56,    0,  472,    2, 0x0a /* Public */,
      57,    0,  473,    2, 0x0a /* Public */,
      58,    1,  474,    2, 0x0a /* Public */,
      59,    0,  477,    2, 0x0a /* Public */,
      61,    1,  478,    2, 0x0a /* Public */,
      63,    0,  481,    2, 0x0a /* Public */,
      64,    1,  482,    2, 0x0a /* Public */,
      65,    0,  485,    2, 0x0a /* Public */,
      66,    1,  486,    2, 0x0a /* Public */,
      68,    1,  489,    2, 0x0a /* Public */,
      70,    0,  492,    2, 0x0a /* Public */,
      71,    1,  493,    2, 0x0a /* Public */,
      73,    3,  496,    2, 0x0a /* Public */,
      73,    2,  503,    2, 0x2a /* Public | MethodCloned */,
      73,    1,  508,    2, 0x2a /* Public | MethodCloned */,
      77,    1,  511,    2, 0x0a /* Public */,
      79,    1,  514,    2, 0x0a /* Public */,
      80,    1,  517,    2, 0x0a /* Public */,
      81,    0,  520,    2, 0x0a /* Public */,
      82,    1,  521,    2, 0x0a /* Public */,
      84,    0,  524,    2, 0x0a /* Public */,
      85,    1,  525,    2, 0x0a /* Public */,
      86,    1,  528,    2, 0x0a /* Public */,
      86,    2,  531,    2, 0x0a /* Public */,
      91,    1,  536,    2, 0x08 /* Private */,
      93,    0,  539,    2, 0x08 /* Private */,

 // signals: parameters
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Void, QMetaType::Bool,   10,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString,   14,
    QMetaType::Void,
    QMetaType::Void, QMetaType::QString,   17,
    QMetaType::Void, QMetaType::QString,   14,

 // slots: parameters
    QMetaType::QStringList,
    QMetaType::QStringList,
    QMetaType::QStringList,
    QMetaType::Void,
    QMetaType::Bool, QMetaType::QString, QMetaType::Double,   24,   25,
    QMetaType::Bool, QMetaType::QString,   24,
    QMetaType::QString,
    QMetaType::Bool, QMetaType::QString, QMetaType::Double,   28,   25,
    QMetaType::Bool, QMetaType::QString,   28,
    0x80000000 | 30,
    QMetaType::Void,
    QMetaType::Bool, QMetaType::QString,   24,
    QMetaType::QString,
    QMetaType::QString,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Bool,
    QMetaType::Float,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   43,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   43,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   48,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   48,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   48,
    QMetaType::Double,
    QMetaType::Void, QMetaType::Double,   48,
    QMetaType::Void, QMetaType::Bool,   10,
    QMetaType::Bool,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,    3,
    0x80000000 | 60,
    QMetaType::Void, 0x80000000 | 60,   62,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,    3,
    QMetaType::Float,
    QMetaType::Void, QMetaType::Float,   67,
    QMetaType::Void, QMetaType::Int,   69,
    QMetaType::Int,
    QMetaType::Void, QMetaType::Float,   72,
    QMetaType::QString, QMetaType::QString, QMetaType::Bool, QMetaType::Bool,   74,   75,   76,
    QMetaType::QString, QMetaType::QString, QMetaType::Bool,   74,   75,
    QMetaType::QString, QMetaType::QString,   74,
    QMetaType::Bool, QMetaType::QString,   78,
    QMetaType::QString, QMetaType::QString,   78,
    QMetaType::ULongLong, QMetaType::QString,   78,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   83,
    QMetaType::Bool,
    QMetaType::Void, QMetaType::Bool,   48,
    QMetaType::Float, 0x80000000 | 87,   88,
    QMetaType::Float, QMetaType::Float, QMetaType::Float,   89,   90,
    QMetaType::Void, QMetaType::QString,   92,
    QMetaType::Void,

 // properties: name, type, flags
      94, QMetaType::Bool, 0x00495003,
      95, QMetaType::Bool, 0x00495003,
      96, QMetaType::Bool, 0x00495003,
      97, QMetaType::Bool, 0x00495003,
      98, QMetaType::Bool, 0x00495003,
      99, QMetaType::Bool, 0x00495003,
     100, QMetaType::Bool, 0x00495003,

 // properties: notify_signal_id
       0,
       1,
       2,
       3,
       4,
       5,
       6,

       0        // eod
};

void LandscapeMgr::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        LandscapeMgr *_t = static_cast<LandscapeMgr *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: _t->atmosphereDisplayedChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 1: _t->cardinalsPointsDisplayedChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 2: _t->fogDisplayedChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 3: _t->landscapeDisplayedChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 4: _t->illuminationDisplayedChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 5: _t->labelsDisplayedChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 6: _t->lightPollutionUsageChanged((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 7: _t->landscapesChanged(); break;
        case 8: _t->lightPollutionChanged(); break;
        case 9: _t->errorUnableToOpen((*reinterpret_cast< QString(*)>(_a[1]))); break;
        case 10: _t->errorNotArchive(); break;
        case 11: _t->errorNotUnique((*reinterpret_cast< QString(*)>(_a[1]))); break;
        case 12: _t->errorRemoveManually((*reinterpret_cast< QString(*)>(_a[1]))); break;
        case 13: { QStringList _r = _t->getAllLandscapeNames();
            if (_a[0]) *reinterpret_cast< QStringList*>(_a[0]) = _r; }  break;
        case 14: { QStringList _r = _t->getAllLandscapeIDs();
            if (_a[0]) *reinterpret_cast< QStringList*>(_a[0]) = _r; }  break;
        case 15: { QStringList _r = _t->getUserLandscapeIDs();
            if (_a[0]) *reinterpret_cast< QStringList*>(_a[0]) = _r; }  break;
        case 16: _t->getCurrentLandscapeID(); break;
        case 17: { bool _r = _t->setCurrentLandscapeID((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const double(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 18: { bool _r = _t->setCurrentLandscapeID((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 19: { QString _r = _t->getCurrentLandscapeName();
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 20: { bool _r = _t->setCurrentLandscapeName((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const double(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 21: { bool _r = _t->setCurrentLandscapeName((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 22: { Landscape* _r = _t->getCurrentLandscape();
            if (_a[0]) *reinterpret_cast< Landscape**>(_a[0]) = _r; }  break;
        case 23: _t->getDefaultLandscapeID(); break;
        case 24: { bool _r = _t->setDefaultLandscapeID((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 25: { QString _r = _t->getCurrentLandscapeHtmlDescription();
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 26: { QString _r = _t->getDescription();
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 27: { bool _r = _t->getFlagLandscape();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 28: _t->setFlagLandscape((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 29: { bool _r = _t->getIsLandscapeFullyVisible();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 30: { float _r = _t->getLandscapeSinMinAltitudeLimit();
            if (_a[0]) *reinterpret_cast< float*>(_a[0]) = _r; }  break;
        case 31: { bool _r = _t->getFlagFog();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 32: _t->setFlagFog((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 33: { bool _r = _t->getFlagIllumination();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 34: _t->setFlagIllumination((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 35: { bool _r = _t->getFlagLabels();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 36: _t->setFlagLabels((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 37: { bool _r = _t->getFlagLandscapeSetsLocation();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 38: _t->setFlagLandscapeSetsLocation((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 39: { bool _r = _t->getFlagLandscapeUseMinimalBrightness();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 40: _t->setFlagLandscapeUseMinimalBrightness((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 41: { bool _r = _t->getFlagLandscapeSetsMinimalBrightness();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 42: _t->setFlagLandscapeSetsMinimalBrightness((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 43: { double _r = _t->getDefaultMinimalBrightness();
            if (_a[0]) *reinterpret_cast< double*>(_a[0]) = _r; }  break;
        case 44: _t->setDefaultMinimalBrightness((*reinterpret_cast< const double(*)>(_a[1]))); break;
        case 45: _t->setFlagUseLightPollutionFromDatabase((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 46: { bool _r = _t->getFlagUseLightPollutionFromDatabase();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 47: { bool _r = _t->getFlagCardinalsPoints();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 48: _t->setFlagCardinalsPoints((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 49: { Vec3f _r = _t->getColorCardinalPoints();
            if (_a[0]) *reinterpret_cast< Vec3f*>(_a[0]) = _r; }  break;
        case 50: _t->setColorCardinalPoints((*reinterpret_cast< const Vec3f(*)>(_a[1]))); break;
        case 51: { bool _r = _t->getFlagAtmosphere();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 52: _t->setFlagAtmosphere((*reinterpret_cast< const bool(*)>(_a[1]))); break;
        case 53: { float _r = _t->getAtmosphereFadeDuration();
            if (_a[0]) *reinterpret_cast< float*>(_a[0]) = _r; }  break;
        case 54: _t->setAtmosphereFadeDuration((*reinterpret_cast< const float(*)>(_a[1]))); break;
        case 55: _t->setAtmosphereBortleLightPollution((*reinterpret_cast< const int(*)>(_a[1]))); break;
        case 56: { int _r = _t->getAtmosphereBortleLightPollution();
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = _r; }  break;
        case 57: _t->setZRotation((*reinterpret_cast< const float(*)>(_a[1]))); break;
        case 58: { QString _r = _t->installLandscapeFromArchive((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< const bool(*)>(_a[2])),(*reinterpret_cast< const bool(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 59: { QString _r = _t->installLandscapeFromArchive((*reinterpret_cast< QString(*)>(_a[1])),(*reinterpret_cast< const bool(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 60: { QString _r = _t->installLandscapeFromArchive((*reinterpret_cast< QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 61: { bool _r = _t->removeLandscape((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 62: { QString _r = _t->loadLandscapeName((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QString*>(_a[0]) = _r; }  break;
        case 63: { quint64 _r = _t->loadLandscapeSize((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< quint64*>(_a[0]) = _r; }  break;
        case 64: { bool _r = _t->getFlagLandscapeAutoSelection();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 65: _t->setFlagLandscapeAutoSelection((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 66: { bool _r = _t->getFlagAtmosphereAutoEnable();
            if (_a[0]) *reinterpret_cast< bool*>(_a[0]) = _r; }  break;
        case 67: _t->setFlagAtmosphereAutoEnable((*reinterpret_cast< bool(*)>(_a[1]))); break;
        case 68: { float _r = _t->getLandscapeOpacity((*reinterpret_cast< Vec3d(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< float*>(_a[0]) = _r; }  break;
        case 69: { float _r = _t->getLandscapeOpacity((*reinterpret_cast< float(*)>(_a[1])),(*reinterpret_cast< float(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< float*>(_a[0]) = _r; }  break;
        case 70: _t->setStelStyle((*reinterpret_cast< const QString(*)>(_a[1]))); break;
        case 71: _t->updateI18n(); break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        void **func = reinterpret_cast<void **>(_a[1]);
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::atmosphereDisplayedChanged)) {
                *result = 0;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::cardinalsPointsDisplayedChanged)) {
                *result = 1;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::fogDisplayedChanged)) {
                *result = 2;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::landscapeDisplayedChanged)) {
                *result = 3;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::illuminationDisplayedChanged)) {
                *result = 4;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::labelsDisplayedChanged)) {
                *result = 5;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(const bool );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::lightPollutionUsageChanged)) {
                *result = 6;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::landscapesChanged)) {
                *result = 7;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::lightPollutionChanged)) {
                *result = 8;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(QString );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::errorUnableToOpen)) {
                *result = 9;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)();
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::errorNotArchive)) {
                *result = 10;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(QString );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::errorNotUnique)) {
                *result = 11;
                return;
            }
        }
        {
            typedef void (LandscapeMgr::*_t)(QString );
            if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&LandscapeMgr::errorRemoveManually)) {
                *result = 12;
                return;
            }
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        LandscapeMgr *_t = static_cast<LandscapeMgr *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< bool*>(_v) = _t->getFlagAtmosphere(); break;
        case 1: *reinterpret_cast< bool*>(_v) = _t->getFlagCardinalsPoints(); break;
        case 2: *reinterpret_cast< bool*>(_v) = _t->getFlagFog(); break;
        case 3: *reinterpret_cast< bool*>(_v) = _t->getFlagLandscape(); break;
        case 4: *reinterpret_cast< bool*>(_v) = _t->getFlagIllumination(); break;
        case 5: *reinterpret_cast< bool*>(_v) = _t->getFlagLabels(); break;
        case 6: *reinterpret_cast< bool*>(_v) = _t->getFlagUseLightPollutionFromDatabase(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
        LandscapeMgr *_t = static_cast<LandscapeMgr *>(_o);
        Q_UNUSED(_t)
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFlagAtmosphere(*reinterpret_cast< bool*>(_v)); break;
        case 1: _t->setFlagCardinalsPoints(*reinterpret_cast< bool*>(_v)); break;
        case 2: _t->setFlagFog(*reinterpret_cast< bool*>(_v)); break;
        case 3: _t->setFlagLandscape(*reinterpret_cast< bool*>(_v)); break;
        case 4: _t->setFlagIllumination(*reinterpret_cast< bool*>(_v)); break;
        case 5: _t->setFlagLabels(*reinterpret_cast< bool*>(_v)); break;
        case 6: _t->setFlagUseLightPollutionFromDatabase(*reinterpret_cast< bool*>(_v)); break;
        default: break;
        }
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

const QMetaObject LandscapeMgr::staticMetaObject = {
    { &StelModule::staticMetaObject, qt_meta_stringdata_LandscapeMgr.data,
      qt_meta_data_LandscapeMgr,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};


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 Q_NULLPTR;
    if (!strcmp(_clname, qt_meta_stringdata_LandscapeMgr.stringdata0))
        return static_cast<void*>(const_cast< LandscapeMgr*>(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 < 72)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 72;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 72)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 72;
    }
#ifndef QT_NO_PROPERTIES
   else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 7;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 7;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 7;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 7;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 7;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void LandscapeMgr::atmosphereDisplayedChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void LandscapeMgr::cardinalsPointsDisplayedChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void LandscapeMgr::fogDisplayedChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void LandscapeMgr::landscapeDisplayedChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void LandscapeMgr::illuminationDisplayedChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void LandscapeMgr::labelsDisplayedChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// SIGNAL 6
void LandscapeMgr::lightPollutionUsageChanged(const bool _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}

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

// SIGNAL 8
void LandscapeMgr::lightPollutionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, Q_NULLPTR);
}

// SIGNAL 9
void LandscapeMgr::errorUnableToOpen(QString _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 9, _a);
}

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

// SIGNAL 11
void LandscapeMgr::errorNotUnique(QString _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 11, _a);
}

// SIGNAL 12
void LandscapeMgr::errorRemoveManually(QString _t1)
{
    void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
    QMetaObject::activate(this, &staticMetaObject, 12, _a);
}
QT_END_MOC_NAMESPACE
