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

template <> constexpr inline auto StelMainView::qt_create_metaobjectdata<qt_meta_tag_ZN12StelMainViewE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "StelMainView",
        "sizeChanged",
        "",
        "QSize",
        "sz",
        "screenshotRequested",
        "fullScreenChanged",
        "b",
        "reloadShadersRequested",
        "updateIconsRequested",
        "flagInvertScreenShotColorsChanged",
        "flagOverwriteScreenshotsChanged",
        "flagUseCustomScreenshotSizeChanged",
        "use",
        "flagScreenshotDateFileNameChanged",
        "flag",
        "customScreenshotWidthChanged",
        "width",
        "customScreenshotHeightChanged",
        "height",
        "screenshotDpiChanged",
        "dpi",
        "screenshotFormatChanged",
        "format",
        "screenshotFileMaskChanged",
        "skyBackgroundColorChanged",
        "Vec3f",
        "color",
        "flagCursorTimeoutChanged",
        "cursorTimeoutChanged",
        "t",
        "minFpsChanged",
        "fps",
        "maxFpsChanged",
        "minTimeBetweenFramesChanged",
        "tbf",
        "frameFinished",
        "setFullScreen",
        "focusSky",
        "saveScreenShot",
        "filePrefix",
        "saveDir",
        "overwrite",
        "setScreenshotFormat",
        "filetype",
        "getScreenshotFormat",
        "getFlagInvertScreenShotColors",
        "setFlagInvertScreenShotColors",
        "getFlagScreenshotDateFileName",
        "setFlagScreenshotDateFileName",
        "setScreenshotFileMask",
        "filemask",
        "getScreenshotFileMask",
        "getFlagOverwriteScreenShots",
        "setFlagOverwriteScreenShots",
        "getFlagUseCustomScreenshotSize",
        "setFlagUseCustomScreenshotSize",
        "getCustomScreenshotWidth",
        "setCustomScreenshotWidth",
        "getCustomScreenshotHeight",
        "setCustomScreenshotHeight",
        "getScreenshotDpi",
        "setScreenshotDpi",
        "getFlagCursorTimeout",
        "setFlagCursorTimeout",
        "getCursorTimeout",
        "setCursorTimeout",
        "setMinFps",
        "m",
        "getMinFps",
        "setMaxFps",
        "getMaxFps",
        "getDesiredFps",
        "setMinTimeBetweenFrames",
        "getMinTimeBetweenFrames",
        "thereWasAnEvent",
        "needsMaxFPS",
        "setSkyBackgroundColor",
        "getSkyBackgroundColor",
        "doScreenshot",
        "fpsTimerUpdate",
        "hideCursor",
        "disableScreensaver",
        "fullscreen",
        "bumpScreensaver",
        "updateNightModeProperty",
        "reloadShaders",
        "fullScreen",
        "flagInvertScreenShotColors",
        "flagScreenshotDateFileName",
        "screenShotFileMask",
        "flagOverwriteScreenshots",
        "flagUseCustomScreenshotSize",
        "customScreenshotWidth",
        "customScreenshotHeight",
        "screenshotDpi",
        "screenShotFormat",
        "flagCursorTimeout",
        "cursorTimeout",
        "skyBackgroundColor",
        "minFps",
        "maxFps",
        "minTimeBetweenFrames"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'sizeChanged'
        QtMocHelpers::SignalData<void(const QSize &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Signal 'screenshotRequested'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fullScreenChanged'
        QtMocHelpers::SignalData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Signal 'reloadShadersRequested'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updateIconsRequested'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'flagInvertScreenShotColorsChanged'
        QtMocHelpers::SignalData<void(bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Signal 'flagOverwriteScreenshotsChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Signal 'flagUseCustomScreenshotSizeChanged'
        QtMocHelpers::SignalData<void(bool)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 13 },
        }}),
        // Signal 'flagScreenshotDateFileNameChanged'
        QtMocHelpers::SignalData<void(bool)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 15 },
        }}),
        // Signal 'customScreenshotWidthChanged'
        QtMocHelpers::SignalData<void(int)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Signal 'customScreenshotHeightChanged'
        QtMocHelpers::SignalData<void(int)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 19 },
        }}),
        // Signal 'screenshotDpiChanged'
        QtMocHelpers::SignalData<void(int)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 21 },
        }}),
        // Signal 'screenshotFormatChanged'
        QtMocHelpers::SignalData<void(QString)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 23 },
        }}),
        // Signal 'screenshotFileMaskChanged'
        QtMocHelpers::SignalData<void(QString)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 23 },
        }}),
        // Signal 'skyBackgroundColorChanged'
        QtMocHelpers::SignalData<void(Vec3f)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Signal 'flagCursorTimeoutChanged'
        QtMocHelpers::SignalData<void(bool)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Signal 'cursorTimeoutChanged'
        QtMocHelpers::SignalData<void(double)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 30 },
        }}),
        // Signal 'minFpsChanged'
        QtMocHelpers::SignalData<void(int)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 32 },
        }}),
        // Signal 'maxFpsChanged'
        QtMocHelpers::SignalData<void(int)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 32 },
        }}),
        // Signal 'minTimeBetweenFramesChanged'
        QtMocHelpers::SignalData<void(int)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 35 },
        }}),
        // Signal 'frameFinished'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setFullScreen'
        QtMocHelpers::SlotData<void(bool)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Slot 'focusSky'
        QtMocHelpers::SlotData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'saveScreenShot'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const bool)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 40 }, { QMetaType::QString, 41 }, { QMetaType::Bool, 42 },
        }}),
        // Slot 'saveScreenShot'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(39, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 40 }, { QMetaType::QString, 41 },
        }}),
        // Slot 'saveScreenShot'
        QtMocHelpers::SlotData<void(const QString &)>(39, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 40 },
        }}),
        // Slot 'saveScreenShot'
        QtMocHelpers::SlotData<void()>(39, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'setScreenshotFormat'
        QtMocHelpers::SlotData<void(const QString)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 44 },
        }}),
        // Slot 'getScreenshotFormat'
        QtMocHelpers::SlotData<QString() const>(45, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getFlagInvertScreenShotColors'
        QtMocHelpers::SlotData<bool() const>(46, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagInvertScreenShotColors'
        QtMocHelpers::SlotData<void(bool)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'getFlagScreenshotDateFileName'
        QtMocHelpers::SlotData<bool() const>(48, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagScreenshotDateFileName'
        QtMocHelpers::SlotData<void(bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'setScreenshotFileMask'
        QtMocHelpers::SlotData<void(const QString)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 51 },
        }}),
        // Slot 'getScreenshotFileMask'
        QtMocHelpers::SlotData<QString() const>(52, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'getFlagOverwriteScreenShots'
        QtMocHelpers::SlotData<bool() const>(53, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagOverwriteScreenShots'
        QtMocHelpers::SlotData<void(bool)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'getFlagUseCustomScreenshotSize'
        QtMocHelpers::SlotData<bool() const>(55, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagUseCustomScreenshotSize'
        QtMocHelpers::SlotData<void(bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'getCustomScreenshotWidth'
        QtMocHelpers::SlotData<int() const>(57, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setCustomScreenshotWidth'
        QtMocHelpers::SlotData<void(int)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 17 },
        }}),
        // Slot 'getCustomScreenshotHeight'
        QtMocHelpers::SlotData<int() const>(59, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setCustomScreenshotHeight'
        QtMocHelpers::SlotData<void(int)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 19 },
        }}),
        // Slot 'getScreenshotDpi'
        QtMocHelpers::SlotData<int() const>(61, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setScreenshotDpi'
        QtMocHelpers::SlotData<void(int)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 21 },
        }}),
        // Slot 'getFlagCursorTimeout'
        QtMocHelpers::SlotData<bool() const>(63, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setFlagCursorTimeout'
        QtMocHelpers::SlotData<void(bool)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'getCursorTimeout'
        QtMocHelpers::SlotData<double() const>(65, 2, QMC::AccessPublic, QMetaType::Double),
        // Slot 'setCursorTimeout'
        QtMocHelpers::SlotData<void(double)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 30 },
        }}),
        // Slot 'setMinFps'
        QtMocHelpers::SlotData<void(float)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 68 },
        }}),
        // Slot 'getMinFps'
        QtMocHelpers::SlotData<float() const>(69, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setMaxFps'
        QtMocHelpers::SlotData<void(float)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 68 },
        }}),
        // Slot 'getMaxFps'
        QtMocHelpers::SlotData<float() const>(71, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'getDesiredFps'
        QtMocHelpers::SlotData<float() const>(72, 2, QMC::AccessPublic, QMetaType::Float),
        // Slot 'setMinTimeBetweenFrames'
        QtMocHelpers::SlotData<void(int)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 68 },
        }}),
        // Slot 'getMinTimeBetweenFrames'
        QtMocHelpers::SlotData<int() const>(74, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'thereWasAnEvent'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'needsMaxFPS'
        QtMocHelpers::SlotData<bool() const>(76, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setSkyBackgroundColor'
        QtMocHelpers::SlotData<void(Vec3f)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Slot 'getSkyBackgroundColor'
        QtMocHelpers::SlotData<Vec3f() const>(78, 2, QMC::AccessPublic, 0x80000000 | 26),
        // Slot 'doScreenshot'
        QtMocHelpers::SlotData<void()>(79, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'fpsTimerUpdate'
        QtMocHelpers::SlotData<void()>(80, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'hideCursor'
        QtMocHelpers::SlotData<void()>(81, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'disableScreensaver'
        QtMocHelpers::SlotData<void(bool)>(82, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 83 },
        }}),
        // Slot 'bumpScreensaver'
        QtMocHelpers::SlotData<void()>(84, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateNightModeProperty'
        QtMocHelpers::SlotData<void(bool)>(85, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Slot 'reloadShaders'
        QtMocHelpers::SlotData<void()>(86, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'fullScreen'
        QtMocHelpers::PropertyData<bool>(87, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'flagInvertScreenShotColors'
        QtMocHelpers::PropertyData<bool>(88, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'flagScreenshotDateFileName'
        QtMocHelpers::PropertyData<bool>(89, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'screenShotFileMask'
        QtMocHelpers::PropertyData<QString>(90, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 13),
        // property 'flagOverwriteScreenshots'
        QtMocHelpers::PropertyData<bool>(91, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 6),
        // property 'flagUseCustomScreenshotSize'
        QtMocHelpers::PropertyData<bool>(92, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'customScreenshotWidth'
        QtMocHelpers::PropertyData<int>(93, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'customScreenshotHeight'
        QtMocHelpers::PropertyData<int>(94, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'screenshotDpi'
        QtMocHelpers::PropertyData<int>(95, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'screenShotFormat'
        QtMocHelpers::PropertyData<QString>(96, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable, 12),
        // property 'flagCursorTimeout'
        QtMocHelpers::PropertyData<bool>(97, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'cursorTimeout'
        QtMocHelpers::PropertyData<double>(98, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'skyBackgroundColor'
        QtMocHelpers::PropertyData<Vec3f>(99, 0x80000000 | 26, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'minFps'
        QtMocHelpers::PropertyData<int>(100, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'maxFps'
        QtMocHelpers::PropertyData<int>(101, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'minTimeBetweenFrames'
        QtMocHelpers::PropertyData<int>(102, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<StelMainView, qt_meta_tag_ZN12StelMainViewE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject StelMainView::staticMetaObject = { {
    QMetaObject::SuperData::link<QGraphicsView::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12StelMainViewE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12StelMainViewE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12StelMainViewE_t>.metaTypes,
    nullptr
} };

void StelMainView::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<StelMainView *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->sizeChanged((*reinterpret_cast<std::add_pointer_t<QSize>>(_a[1]))); break;
        case 1: _t->screenshotRequested(); break;
        case 2: _t->fullScreenChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->reloadShadersRequested(); break;
        case 4: _t->updateIconsRequested(); break;
        case 5: _t->flagInvertScreenShotColorsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->flagOverwriteScreenshotsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->flagUseCustomScreenshotSizeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->flagScreenshotDateFileNameChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->customScreenshotWidthChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->customScreenshotHeightChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->screenshotDpiChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->screenshotFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 13: _t->screenshotFileMaskChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->skyBackgroundColorChanged((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 15: _t->flagCursorTimeoutChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->cursorTimeoutChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 17: _t->minFpsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 18: _t->maxFpsChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 19: _t->minTimeBetweenFramesChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 20: _t->frameFinished(); break;
        case 21: _t->setFullScreen((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->focusSky(); break;
        case 23: _t->saveScreenShot((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 24: _t->saveScreenShot((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 25: _t->saveScreenShot((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->saveScreenShot(); break;
        case 27: _t->setScreenshotFormat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 28: { QString _r = _t->getScreenshotFormat();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 29: { bool _r = _t->getFlagInvertScreenShotColors();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 30: _t->setFlagInvertScreenShotColors((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: { bool _r = _t->getFlagScreenshotDateFileName();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 32: _t->setFlagScreenshotDateFileName((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->setScreenshotFileMask((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 34: { QString _r = _t->getScreenshotFileMask();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 35: { bool _r = _t->getFlagOverwriteScreenShots();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: _t->setFlagOverwriteScreenShots((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: { bool _r = _t->getFlagUseCustomScreenshotSize();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 38: _t->setFlagUseCustomScreenshotSize((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: { int _r = _t->getCustomScreenshotWidth();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 40: _t->setCustomScreenshotWidth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 41: { int _r = _t->getCustomScreenshotHeight();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 42: _t->setCustomScreenshotHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 43: { int _r = _t->getScreenshotDpi();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 44: _t->setScreenshotDpi((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 45: { bool _r = _t->getFlagCursorTimeout();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: _t->setFlagCursorTimeout((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 47: { double _r = _t->getCursorTimeout();
            if (_a[0]) *reinterpret_cast<double*>(_a[0]) = std::move(_r); }  break;
        case 48: _t->setCursorTimeout((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 49: _t->setMinFps((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 50: { float _r = _t->getMinFps();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 51: _t->setMaxFps((*reinterpret_cast<std::add_pointer_t<float>>(_a[1]))); break;
        case 52: { float _r = _t->getMaxFps();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 53: { float _r = _t->getDesiredFps();
            if (_a[0]) *reinterpret_cast<float*>(_a[0]) = std::move(_r); }  break;
        case 54: _t->setMinTimeBetweenFrames((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 55: { int _r = _t->getMinTimeBetweenFrames();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 56: _t->thereWasAnEvent(); break;
        case 57: { bool _r = _t->needsMaxFPS();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 58: _t->setSkyBackgroundColor((*reinterpret_cast<std::add_pointer_t<Vec3f>>(_a[1]))); break;
        case 59: { Vec3f _r = _t->getSkyBackgroundColor();
            if (_a[0]) *reinterpret_cast<Vec3f*>(_a[0]) = std::move(_r); }  break;
        case 60: _t->doScreenshot(); break;
        case 61: _t->fpsTimerUpdate(); break;
        case 62: _t->hideCursor(); break;
        case 63: _t->disableScreensaver((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: _t->bumpScreensaver(); break;
        case 65: _t->updateNightModeProperty((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 66: _t->reloadShaders(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 14:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        case 58:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Vec3f >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(const QSize & )>(_a, &StelMainView::sizeChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)()>(_a, &StelMainView::screenshotRequested, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(bool )>(_a, &StelMainView::fullScreenChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)()>(_a, &StelMainView::reloadShadersRequested, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)()>(_a, &StelMainView::updateIconsRequested, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(bool )>(_a, &StelMainView::flagInvertScreenShotColorsChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(bool )>(_a, &StelMainView::flagOverwriteScreenshotsChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(bool )>(_a, &StelMainView::flagUseCustomScreenshotSizeChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(bool )>(_a, &StelMainView::flagScreenshotDateFileNameChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(int )>(_a, &StelMainView::customScreenshotWidthChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(int )>(_a, &StelMainView::customScreenshotHeightChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(int )>(_a, &StelMainView::screenshotDpiChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(QString )>(_a, &StelMainView::screenshotFormatChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(QString )>(_a, &StelMainView::screenshotFileMaskChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(Vec3f )>(_a, &StelMainView::skyBackgroundColorChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(bool )>(_a, &StelMainView::flagCursorTimeoutChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(double )>(_a, &StelMainView::cursorTimeoutChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(int )>(_a, &StelMainView::minFpsChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(int )>(_a, &StelMainView::maxFpsChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)(int )>(_a, &StelMainView::minTimeBetweenFramesChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (StelMainView::*)()>(_a, &StelMainView::frameFinished, 20))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 12:
            *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->isFullScreen(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->getFlagInvertScreenShotColors(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->getFlagScreenshotDateFileName(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->getScreenshotFileMask(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->getFlagOverwriteScreenShots(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->getFlagUseCustomScreenshotSize(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->getCustomScreenshotWidth(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->getCustomScreenshotHeight(); break;
        case 8: *reinterpret_cast<int*>(_v) = _t->getScreenshotDpi(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->getScreenshotFormat(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->getFlagCursorTimeout(); break;
        case 11: *reinterpret_cast<double*>(_v) = _t->getCursorTimeout(); break;
        case 12: *reinterpret_cast<Vec3f*>(_v) = _t->getSkyBackgroundColor(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->getMinFps(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->getMaxFps(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->getMinTimeBetweenFrames(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFullScreen(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setFlagInvertScreenShotColors(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setFlagScreenshotDateFileName(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->setScreenshotFileMask(*reinterpret_cast<QString*>(_v)); break;
        case 4: _t->setFlagOverwriteScreenShots(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setFlagUseCustomScreenshotSize(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setCustomScreenshotWidth(*reinterpret_cast<int*>(_v)); break;
        case 7: _t->setCustomScreenshotHeight(*reinterpret_cast<int*>(_v)); break;
        case 8: _t->setScreenshotDpi(*reinterpret_cast<int*>(_v)); break;
        case 9: _t->setScreenshotFormat(*reinterpret_cast<QString*>(_v)); break;
        case 10: _t->setFlagCursorTimeout(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setCursorTimeout(*reinterpret_cast<double*>(_v)); break;
        case 12: _t->setSkyBackgroundColor(*reinterpret_cast<Vec3f*>(_v)); break;
        case 13: _t->setMinFps(*reinterpret_cast<int*>(_v)); break;
        case 14: _t->setMaxFps(*reinterpret_cast<int*>(_v)); break;
        case 15: _t->setMinTimeBetweenFrames(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void StelMainView::sizeChanged(const QSize & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void StelMainView::screenshotRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void StelMainView::fullScreenChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void StelMainView::reloadShadersRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void StelMainView::updateIconsRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

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

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

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

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

// SIGNAL 9
void StelMainView::customScreenshotWidthChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

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

// SIGNAL 11
void StelMainView::screenshotDpiChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void StelMainView::screenshotFormatChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void StelMainView::screenshotFileMaskChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void StelMainView::skyBackgroundColorChanged(Vec3f _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void StelMainView::flagCursorTimeoutChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

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

// SIGNAL 17
void StelMainView::minFpsChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

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

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

// SIGNAL 20
void StelMainView::frameFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}
QT_WARNING_POP
