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

#include "../../../../../../../marble-26.04.3/src/lib/marble/declarative/MarbleQuickItem.h"
#include "MarbleQuickItem.h"
#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 'MarbleQuickItem.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN6Marble15MarbleQuickItemE_t {};
} // unnamed namespace

template <> constexpr inline auto Marble::MarbleQuickItem::qt_create_metaobjectdata<qt_meta_tag_ZN6Marble15MarbleQuickItemE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Marble::MarbleQuickItem",
        "QML.Element",
        "MarbleItem",
        "mapWidthChanged",
        "",
        "mapWidth",
        "mapHeightChanged",
        "mapHeight",
        "showFrameRateChanged",
        "showFrameRate",
        "projectionChanged",
        "Projection",
        "projection",
        "mapThemeIdChanged",
        "mapThemeId",
        "mapThemeChanged",
        "showAtmosphereChanged",
        "showAtmosphere",
        "showCompassChanged",
        "showCompass",
        "showCloudsChanged",
        "showClouds",
        "showCrosshairsChanged",
        "showCrosshairs",
        "showGridChanged",
        "showGrid",
        "showOverviewMapChanged",
        "showOverviewMap",
        "showOtherPlacesChanged",
        "showOtherPlaces",
        "showScaleBarChanged",
        "showScaleBar",
        "showBackgroundChanged",
        "showBackground",
        "showPositionMarkerChanged",
        "showPositionMarker",
        "showPublicTransportChanged",
        "showPublicTransport",
        "showOutdoorActivitiesChanged",
        "showOutdoorActivities",
        "positionProviderChanged",
        "positionProvider",
        "positionAvailableChanged",
        "positionAvailable",
        "positionVisibleChanged",
        "positionVisible",
        "marbleMapChanged",
        "visibleLatLonAltBoxChanged",
        "currentPositionChanged",
        "Placemark*",
        "currentPosition",
        "angleChanged",
        "speedChanged",
        "headingChanged",
        "heading",
        "zoomChanged",
        "radiusChanged",
        "radius",
        "inertialGlobeRotationChanged",
        "inertialGlobeRotation",
        "animationViewContextChanged",
        "animationViewContext",
        "placemarkDelegateChanged",
        "QQmlComponent*",
        "placemarkDelegate",
        "animationsEnabledChanged",
        "animationsEnabled",
        "hoverEnabledChanged",
        "hoverEnabled",
        "lmbMenuRequested",
        "QPoint",
        "point",
        "rmbMenuRequested",
        "hoverPositionChanged",
        "minimumZoomChanged",
        "minimumZoom",
        "maximumZoomChanged",
        "maximumZoom",
        "invertColorEnabledChanged",
        "enabled",
        "workOfflineChanged",
        "geoItemUpdateRequested",
        "goHome",
        "setZoom",
        "zoom",
        "FlyToMode",
        "mode",
        "setZoomToMaximumLevel",
        "setRadius",
        "centerOn",
        "GeoDataPlacemark",
        "placemark",
        "animated",
        "GeoDataLatLonBox",
        "box",
        "GeoDataCoordinates",
        "coordinate",
        "longitude",
        "latitude",
        "centerOnCoordinates",
        "centerOnCurrentPosition",
        "selectPlacemarkAt",
        "x",
        "y",
        "zoomIn",
        "zoomOut",
        "handlePinchStarted",
        "QPointF",
        "handlePinchFinished",
        "handlePinchUpdated",
        "scale",
        "setMapWidth",
        "setMapHeight",
        "setShowFrameRate",
        "setProjection",
        "setMapThemeId",
        "setShowAtmosphere",
        "setShowCompass",
        "setShowClouds",
        "setShowCrosshairs",
        "setShowGrid",
        "setShowOverviewMap",
        "setShowOtherPlaces",
        "setShowScaleBar",
        "setShowBackground",
        "setShowPositionMarker",
        "setShowPublicTransport",
        "setShowOutdoorActivities",
        "setPositionProvider",
        "setInertialGlobeRotation",
        "setAnimationViewContext",
        "setAnimationsEnabled",
        "setPluginSetting",
        "plugin",
        "key",
        "value",
        "setPropertyEnabled",
        "property",
        "isPropertyEnabled",
        "setWorkOffline",
        "setInvertColorEnabled",
        "blending",
        "setShowRuntimeTrace",
        "showRuntimeTrace",
        "setShowDebugPolygons",
        "showDebugPolygons",
        "setShowDebugPlacemarks",
        "showDebugPlacemarks",
        "setShowDebugBatches",
        "showDebugBatches",
        "setPlacemarkDelegate",
        "loadSettings",
        "writeSettings",
        "reloadTiles",
        "highlightRouteRelation",
        "osmId",
        "setRelationTypeVisible",
        "relationType",
        "visible",
        "isRelationTypeVisible",
        "setHeading",
        "setHoverEnabled",
        "centerLongitude",
        "centerLatitude",
        "resizeMap",
        "positionDataStatusChanged",
        "PositionProviderStatus",
        "status",
        "positionChanged",
        "GeoDataAccuracy",
        "updatePositionVisibility",
        "updateCurrentPosition",
        "coordinates",
        "updatePlacemarks",
        "handleReverseGeocoding",
        "handleVisibleLatLonAltBoxChanged",
        "GeoDataLatLonAltBox",
        "latLonAltBox",
        "distanceFromPointToCurrentLocation",
        "position",
        "angleFromPointToCurrentLocation",
        "screenCoordinatesFromCoordinate",
        "Coordinate*",
        "screenCoordinatesFromGeoDataCoordinates",
        "screenCoordinatesToCoordinate",
        "invertColorEnabled",
        "moveUp",
        "moveDown",
        "moveLeft",
        "moveRight",
        "mapTheme",
        "Marble::MapTheme*",
        "marbleMap",
        "MarbleMap*",
        "speed",
        "angle",
        "workOffline",
        "Spherical",
        "Equirectangular",
        "Mercator",
        "Gnomonic",
        "Stereographic",
        "LambertAzimuthal",
        "AzimuthalEquidistant",
        "VerticalPerspective"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'mapWidthChanged'
        QtMocHelpers::SignalData<void(int)>(3, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Signal 'mapHeightChanged'
        QtMocHelpers::SignalData<void(int)>(6, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 7 },
        }}),
        // Signal 'showFrameRateChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Signal 'projectionChanged'
        QtMocHelpers::SignalData<void(enum Projection)>(10, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Signal 'mapThemeIdChanged'
        QtMocHelpers::SignalData<void(const QString &)>(13, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Signal 'mapThemeChanged'
        QtMocHelpers::SignalData<void()>(15, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showAtmosphereChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'showCompassChanged'
        QtMocHelpers::SignalData<void(bool)>(18, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Signal 'showCloudsChanged'
        QtMocHelpers::SignalData<void(bool)>(20, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 21 },
        }}),
        // Signal 'showCrosshairsChanged'
        QtMocHelpers::SignalData<void(bool)>(22, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Signal 'showGridChanged'
        QtMocHelpers::SignalData<void(bool)>(24, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Signal 'showOverviewMapChanged'
        QtMocHelpers::SignalData<void(bool)>(26, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 27 },
        }}),
        // Signal 'showOtherPlacesChanged'
        QtMocHelpers::SignalData<void(bool)>(28, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 29 },
        }}),
        // Signal 'showScaleBarChanged'
        QtMocHelpers::SignalData<void(bool)>(30, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 31 },
        }}),
        // Signal 'showBackgroundChanged'
        QtMocHelpers::SignalData<void(bool)>(32, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 33 },
        }}),
        // Signal 'showPositionMarkerChanged'
        QtMocHelpers::SignalData<void(bool)>(34, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 35 },
        }}),
        // Signal 'showPublicTransportChanged'
        QtMocHelpers::SignalData<void(bool)>(36, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 37 },
        }}),
        // Signal 'showOutdoorActivitiesChanged'
        QtMocHelpers::SignalData<void(bool)>(38, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 39 },
        }}),
        // Signal 'positionProviderChanged'
        QtMocHelpers::SignalData<void(const QString &)>(40, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'positionAvailableChanged'
        QtMocHelpers::SignalData<void(bool)>(42, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 43 },
        }}),
        // Signal 'positionVisibleChanged'
        QtMocHelpers::SignalData<void(bool)>(44, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 45 },
        }}),
        // Signal 'marbleMapChanged'
        QtMocHelpers::SignalData<void()>(46, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'visibleLatLonAltBoxChanged'
        QtMocHelpers::SignalData<void()>(47, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'currentPositionChanged'
        QtMocHelpers::SignalData<void(Placemark *)>(48, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 49, 50 },
        }}),
        // Signal 'angleChanged'
        QtMocHelpers::SignalData<void()>(51, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'speedChanged'
        QtMocHelpers::SignalData<void()>(52, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'headingChanged'
        QtMocHelpers::SignalData<void(qreal)>(53, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 54 },
        }}),
        // Signal 'zoomChanged'
        QtMocHelpers::SignalData<void()>(55, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'radiusChanged'
        QtMocHelpers::SignalData<void(int)>(56, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 57 },
        }}),
        // Signal 'inertialGlobeRotationChanged'
        QtMocHelpers::SignalData<void(bool)>(58, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 59 },
        }}),
        // Signal 'animationViewContextChanged'
        QtMocHelpers::SignalData<void(bool)>(60, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 61 },
        }}),
        // Signal 'placemarkDelegateChanged'
        QtMocHelpers::SignalData<void(QQmlComponent *)>(62, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 63, 64 },
        }}),
        // Signal 'animationsEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(65, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 66 },
        }}),
        // Signal 'hoverEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(67, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 68 },
        }}),
        // Signal 'lmbMenuRequested'
        QtMocHelpers::SignalData<void(const QPoint &)>(69, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 70, 71 },
        }}),
        // Signal 'rmbMenuRequested'
        QtMocHelpers::SignalData<void(const QPoint &)>(72, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 70, 71 },
        }}),
        // Signal 'hoverPositionChanged'
        QtMocHelpers::SignalData<void(const QPoint &)>(73, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 70, 71 },
        }}),
        // Signal 'minimumZoomChanged'
        QtMocHelpers::SignalData<void(int)>(74, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 75 },
        }}),
        // Signal 'maximumZoomChanged'
        QtMocHelpers::SignalData<void(int)>(76, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 77 },
        }}),
        // Signal 'invertColorEnabledChanged'
        QtMocHelpers::SignalData<void(bool)>(78, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 79 },
        }}),
        // Signal 'workOfflineChanged'
        QtMocHelpers::SignalData<void()>(80, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'geoItemUpdateRequested'
        QtMocHelpers::SignalData<void()>(81, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'goHome'
        QtMocHelpers::SlotData<void()>(82, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setZoom'
        QtMocHelpers::SlotData<void(int, FlyToMode)>(83, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 84 }, { 0x80000000 | 85, 86 },
        }}),
        // Slot 'setZoom'
        QtMocHelpers::SlotData<void(int)>(83, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Int, 84 },
        }}),
        // Slot 'setZoomToMaximumLevel'
        QtMocHelpers::SlotData<void()>(87, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setRadius'
        QtMocHelpers::SlotData<void(int)>(88, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 57 },
        }}),
        // Slot 'centerOn'
        QtMocHelpers::SlotData<void(const GeoDataPlacemark &, bool)>(89, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 90, 91 }, { QMetaType::Bool, 92 },
        }}),
        // Slot 'centerOn'
        QtMocHelpers::SlotData<void(const GeoDataPlacemark &)>(89, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 90, 91 },
        }}),
        // Slot 'centerOn'
        QtMocHelpers::SlotData<void(const GeoDataLatLonBox &, bool)>(89, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 93, 94 }, { QMetaType::Bool, 92 },
        }}),
        // Slot 'centerOn'
        QtMocHelpers::SlotData<void(const GeoDataLatLonBox &)>(89, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 93, 94 },
        }}),
        // Slot 'centerOn'
        QtMocHelpers::SlotData<void(const GeoDataCoordinates &)>(89, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 95, 96 },
        }}),
        // Slot 'centerOn'
        QtMocHelpers::SlotData<void(qreal, qreal)>(89, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 97 }, { QMetaType::QReal, 98 },
        }}),
        // Slot 'centerOnCoordinates'
        QtMocHelpers::SlotData<void(qreal, qreal)>(99, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 97 }, { QMetaType::QReal, 98 },
        }}),
        // Slot 'centerOnCurrentPosition'
        QtMocHelpers::SlotData<void()>(100, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'selectPlacemarkAt'
        QtMocHelpers::SlotData<void(int, int)>(101, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 102 }, { QMetaType::Int, 103 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void(FlyToMode)>(104, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 85, 86 },
        }}),
        // Slot 'zoomIn'
        QtMocHelpers::SlotData<void()>(104, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void(FlyToMode)>(105, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 85, 86 },
        }}),
        // Slot 'zoomOut'
        QtMocHelpers::SlotData<void()>(105, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'handlePinchStarted'
        QtMocHelpers::SlotData<void(const QPointF &)>(106, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 107, 71 },
        }}),
        // Slot 'handlePinchFinished'
        QtMocHelpers::SlotData<void(const QPointF &)>(108, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 107, 71 },
        }}),
        // Slot 'handlePinchUpdated'
        QtMocHelpers::SlotData<void(const QPointF &, qreal)>(109, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 107, 71 }, { QMetaType::QReal, 110 },
        }}),
        // Slot 'setMapWidth'
        QtMocHelpers::SlotData<void(int)>(111, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Slot 'setMapHeight'
        QtMocHelpers::SlotData<void(int)>(112, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 7 },
        }}),
        // Slot 'setShowFrameRate'
        QtMocHelpers::SlotData<void(bool)>(113, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Slot 'setProjection'
        QtMocHelpers::SlotData<void(enum Projection)>(114, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 11, 12 },
        }}),
        // Slot 'setMapThemeId'
        QtMocHelpers::SlotData<void(const QString &)>(115, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Slot 'setShowAtmosphere'
        QtMocHelpers::SlotData<void(bool)>(116, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Slot 'setShowCompass'
        QtMocHelpers::SlotData<void(bool)>(117, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Slot 'setShowClouds'
        QtMocHelpers::SlotData<void(bool)>(118, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 21 },
        }}),
        // Slot 'setShowCrosshairs'
        QtMocHelpers::SlotData<void(bool)>(119, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setShowGrid'
        QtMocHelpers::SlotData<void(bool)>(120, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Slot 'setShowOverviewMap'
        QtMocHelpers::SlotData<void(bool)>(121, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 27 },
        }}),
        // Slot 'setShowOtherPlaces'
        QtMocHelpers::SlotData<void(bool)>(122, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 29 },
        }}),
        // Slot 'setShowScaleBar'
        QtMocHelpers::SlotData<void(bool)>(123, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 31 },
        }}),
        // Slot 'setShowBackground'
        QtMocHelpers::SlotData<void(bool)>(124, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 33 },
        }}),
        // Slot 'setShowPositionMarker'
        QtMocHelpers::SlotData<void(bool)>(125, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 35 },
        }}),
        // Slot 'setShowPublicTransport'
        QtMocHelpers::SlotData<void(bool)>(126, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'setShowOutdoorActivities'
        QtMocHelpers::SlotData<void(bool)>(127, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 39 },
        }}),
        // Slot 'setPositionProvider'
        QtMocHelpers::SlotData<void(const QString &)>(128, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Slot 'setInertialGlobeRotation'
        QtMocHelpers::SlotData<void(bool)>(129, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 59 },
        }}),
        // Slot 'setAnimationViewContext'
        QtMocHelpers::SlotData<void(bool)>(130, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 61 },
        }}),
        // Slot 'setAnimationsEnabled'
        QtMocHelpers::SlotData<void(bool)>(131, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 66 },
        }}),
        // Slot 'setPluginSetting'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &)>(132, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 133 }, { QMetaType::QString, 134 }, { QMetaType::QString, 135 },
        }}),
        // Slot 'setPropertyEnabled'
        QtMocHelpers::SlotData<void(const QString &, bool)>(136, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 137 }, { QMetaType::Bool, 79 },
        }}),
        // Slot 'isPropertyEnabled'
        QtMocHelpers::SlotData<bool(const QString &) const>(138, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 137 },
        }}),
        // Slot 'setWorkOffline'
        QtMocHelpers::SlotData<void(bool)>(139, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 79 },
        }}),
        // Slot 'setInvertColorEnabled'
        QtMocHelpers::SlotData<void(bool, const QString &)>(140, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 79 }, { QMetaType::QString, 141 },
        }}),
        // Slot 'setInvertColorEnabled'
        QtMocHelpers::SlotData<void(bool)>(140, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::Bool, 79 },
        }}),
        // Slot 'setShowRuntimeTrace'
        QtMocHelpers::SlotData<void(bool)>(142, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 143 },
        }}),
        // Slot 'setShowDebugPolygons'
        QtMocHelpers::SlotData<void(bool)>(144, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 145 },
        }}),
        // Slot 'setShowDebugPlacemarks'
        QtMocHelpers::SlotData<void(bool)>(146, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 147 },
        }}),
        // Slot 'setShowDebugBatches'
        QtMocHelpers::SlotData<void(bool)>(148, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 149 },
        }}),
        // Slot 'setPlacemarkDelegate'
        QtMocHelpers::SlotData<void(QQmlComponent *)>(150, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 63, 64 },
        }}),
        // Slot 'loadSettings'
        QtMocHelpers::SlotData<void()>(151, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'writeSettings'
        QtMocHelpers::SlotData<void()>(152, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reloadTiles'
        QtMocHelpers::SlotData<void()>(153, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'highlightRouteRelation'
        QtMocHelpers::SlotData<void(qint64, bool)>(154, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::LongLong, 155 }, { QMetaType::Bool, 79 },
        }}),
        // Slot 'setRelationTypeVisible'
        QtMocHelpers::SlotData<void(const QString &, bool)>(156, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 157 }, { QMetaType::Bool, 158 },
        }}),
        // Slot 'isRelationTypeVisible'
        QtMocHelpers::SlotData<bool(const QString &) const>(159, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 157 },
        }}),
        // Slot 'setHeading'
        QtMocHelpers::SlotData<void(qreal)>(160, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QReal, 54 },
        }}),
        // Slot 'setHoverEnabled'
        QtMocHelpers::SlotData<void(bool)>(161, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 68 },
        }}),
        // Slot 'centerLongitude'
        QtMocHelpers::SlotData<qreal() const>(162, 4, QMC::AccessPublic, QMetaType::QReal),
        // Slot 'centerLatitude'
        QtMocHelpers::SlotData<qreal() const>(163, 4, QMC::AccessPublic, QMetaType::QReal),
        // Slot 'resizeMap'
        QtMocHelpers::SlotData<void()>(164, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'positionDataStatusChanged'
        QtMocHelpers::SlotData<void(PositionProviderStatus)>(165, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 },
        }}),
        // Slot 'positionChanged'
        QtMocHelpers::SlotData<void(const GeoDataCoordinates &, GeoDataAccuracy)>(168, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 95, 4 }, { 0x80000000 | 169, 4 },
        }}),
        // Slot 'updatePositionVisibility'
        QtMocHelpers::SlotData<void()>(170, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'updateCurrentPosition'
        QtMocHelpers::SlotData<void(const GeoDataCoordinates &)>(171, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 95, 172 },
        }}),
        // Slot 'updatePlacemarks'
        QtMocHelpers::SlotData<void()>(173, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'handleReverseGeocoding'
        QtMocHelpers::SlotData<void(const GeoDataCoordinates &, const GeoDataPlacemark &)>(174, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 95, 172 }, { 0x80000000 | 90, 91 },
        }}),
        // Slot 'handleVisibleLatLonAltBoxChanged'
        QtMocHelpers::SlotData<void(const GeoDataLatLonAltBox &)>(175, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 176, 177 },
        }}),
        // Method 'distanceFromPointToCurrentLocation'
        QtMocHelpers::MethodData<qreal(const QPoint &) const>(178, 4, QMC::AccessPublic, QMetaType::QReal, {{
            { 0x80000000 | 70, 179 },
        }}),
        // Method 'angleFromPointToCurrentLocation'
        QtMocHelpers::MethodData<qreal(const QPoint &) const>(180, 4, QMC::AccessPublic, QMetaType::QReal, {{
            { 0x80000000 | 70, 179 },
        }}),
        // Method 'screenCoordinatesFromCoordinate'
        QtMocHelpers::MethodData<QPointF(Coordinate *) const>(181, 4, QMC::AccessPublic, 0x80000000 | 107, {{
            { 0x80000000 | 182, 96 },
        }}),
        // Method 'screenCoordinatesFromGeoDataCoordinates'
        QtMocHelpers::MethodData<QPointF(const GeoDataCoordinates &) const>(183, 4, QMC::AccessPublic, 0x80000000 | 107, {{
            { 0x80000000 | 95, 172 },
        }}),
        // Method 'screenCoordinatesToCoordinate'
        QtMocHelpers::MethodData<bool(const QPoint &, Coordinate *)>(184, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 70, 71 }, { 0x80000000 | 182, 96 },
        }}),
        // Method 'invertColorEnabled'
        QtMocHelpers::MethodData<bool()>(185, 4, QMC::AccessPublic, QMetaType::Bool),
        // Method 'moveUp'
        QtMocHelpers::MethodData<void()>(186, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'moveDown'
        QtMocHelpers::MethodData<void()>(187, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'moveLeft'
        QtMocHelpers::MethodData<void()>(188, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'moveRight'
        QtMocHelpers::MethodData<void()>(189, 4, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'mapWidth'
        QtMocHelpers::PropertyData<int>(5, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'mapHeight'
        QtMocHelpers::PropertyData<int>(7, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'zoom'
        QtMocHelpers::PropertyData<int>(84, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'minimumZoom'
        QtMocHelpers::PropertyData<int>(75, QMetaType::Int, QMC::DefaultPropertyFlags, 37),
        // property 'maximumZoom'
        QtMocHelpers::PropertyData<int>(77, QMetaType::Int, QMC::DefaultPropertyFlags, 38),
        // property 'radius'
        QtMocHelpers::PropertyData<int>(57, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'heading'
        QtMocHelpers::PropertyData<qreal>(54, QMetaType::QReal, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'showFrameRate'
        QtMocHelpers::PropertyData<bool>(9, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'projection'
        QtMocHelpers::PropertyData<enum Projection>(12, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 3),
        // property 'mapTheme'
        QtMocHelpers::PropertyData<Marble::MapTheme*>(190, 0x80000000 | 191, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'mapThemeId'
        QtMocHelpers::PropertyData<QString>(14, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'showAtmosphere'
        QtMocHelpers::PropertyData<bool>(17, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'showCompass'
        QtMocHelpers::PropertyData<bool>(19, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'showClouds'
        QtMocHelpers::PropertyData<bool>(21, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'showCrosshairs'
        QtMocHelpers::PropertyData<bool>(23, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'showGrid'
        QtMocHelpers::PropertyData<bool>(25, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'showOverviewMap'
        QtMocHelpers::PropertyData<bool>(27, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'showOtherPlaces'
        QtMocHelpers::PropertyData<bool>(29, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'showScaleBar'
        QtMocHelpers::PropertyData<bool>(31, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'showBackground'
        QtMocHelpers::PropertyData<bool>(33, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'showPositionMarker'
        QtMocHelpers::PropertyData<bool>(35, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'showPublicTransport'
        QtMocHelpers::PropertyData<bool>(37, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'showOutdoorActivities'
        QtMocHelpers::PropertyData<bool>(39, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'positionProvider'
        QtMocHelpers::PropertyData<QString>(41, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'positionAvailable'
        QtMocHelpers::PropertyData<bool>(43, QMetaType::Bool, QMC::DefaultPropertyFlags, 19),
        // property 'positionVisible'
        QtMocHelpers::PropertyData<bool>(45, QMetaType::Bool, QMC::DefaultPropertyFlags, 20),
        // property 'marbleMap'
        QtMocHelpers::PropertyData<MarbleMap*>(192, 0x80000000 | 193, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 21),
        // property 'currentPosition'
        QtMocHelpers::PropertyData<Placemark*>(50, 0x80000000 | 49, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 23),
        // property 'speed'
        QtMocHelpers::PropertyData<qreal>(194, QMetaType::QReal, QMC::DefaultPropertyFlags, 25),
        // property 'angle'
        QtMocHelpers::PropertyData<qreal>(195, QMetaType::QReal, QMC::DefaultPropertyFlags, 24),
        // property 'inertialGlobeRotation'
        QtMocHelpers::PropertyData<bool>(59, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'animationViewContext'
        QtMocHelpers::PropertyData<bool>(61, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 30),
        // property 'animationsEnabled'
        QtMocHelpers::PropertyData<bool>(66, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 32),
        // property 'placemarkDelegate'
        QtMocHelpers::PropertyData<QQmlComponent*>(64, 0x80000000 | 63, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 31),
        // property 'hoverEnabled'
        QtMocHelpers::PropertyData<bool>(68, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 33),
        // property 'invertColorEnabled'
        QtMocHelpers::PropertyData<bool>(185, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 39),
        // property 'workOffline'
        QtMocHelpers::PropertyData<bool>(196, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 40),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Projection'
        QtMocHelpers::EnumData<enum Projection>(11, 11, QMC::EnumFlags{}).add({
            {  197, Projection::Spherical },
            {  198, Projection::Equirectangular },
            {  199, Projection::Mercator },
            {  200, Projection::Gnomonic },
            {  201, Projection::Stereographic },
            {  202, Projection::LambertAzimuthal },
            {  203, Projection::AzimuthalEquidistant },
            {  204, Projection::VerticalPerspective },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<MarbleQuickItem, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Marble::MarbleQuickItem::staticMetaObject = { {
    QMetaObject::SuperData::link<QQuickPaintedItem::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Marble15MarbleQuickItemE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Marble15MarbleQuickItemE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Marble15MarbleQuickItemE_t>.metaTypes,
    nullptr
} };

void Marble::MarbleQuickItem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<MarbleQuickItem *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->mapWidthChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 1: _t->mapHeightChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->showFrameRateChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->projectionChanged((*reinterpret_cast<std::add_pointer_t<enum Projection>>(_a[1]))); break;
        case 4: _t->mapThemeIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->mapThemeChanged(); break;
        case 6: _t->showAtmosphereChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->showCompassChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 8: _t->showCloudsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->showCrosshairsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 10: _t->showGridChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->showOverviewMapChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->showOtherPlacesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->showScaleBarChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->showBackgroundChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->showPositionMarkerChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 16: _t->showPublicTransportChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->showOutdoorActivitiesChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->positionProviderChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->positionAvailableChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 20: _t->positionVisibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 21: _t->marbleMapChanged(); break;
        case 22: _t->visibleLatLonAltBoxChanged(); break;
        case 23: _t->currentPositionChanged((*reinterpret_cast<std::add_pointer_t<Placemark*>>(_a[1]))); break;
        case 24: _t->angleChanged(); break;
        case 25: _t->speedChanged(); break;
        case 26: _t->headingChanged((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 27: _t->zoomChanged(); break;
        case 28: _t->radiusChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 29: _t->inertialGlobeRotationChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->animationViewContextChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: _t->placemarkDelegateChanged((*reinterpret_cast<std::add_pointer_t<QQmlComponent*>>(_a[1]))); break;
        case 32: _t->animationsEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 33: _t->hoverEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 34: _t->lmbMenuRequested((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 35: _t->rmbMenuRequested((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 36: _t->hoverPositionChanged((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1]))); break;
        case 37: _t->minimumZoomChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 38: _t->maximumZoomChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 39: _t->invertColorEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: _t->workOfflineChanged(); break;
        case 41: _t->geoItemUpdateRequested(); break;
        case 42: _t->goHome(); break;
        case 43: _t->setZoom((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<FlyToMode>>(_a[2]))); break;
        case 44: _t->setZoom((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 45: _t->setZoomToMaximumLevel(); break;
        case 46: _t->setRadius((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 47: _t->centerOn((*reinterpret_cast<std::add_pointer_t<GeoDataPlacemark>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 48: _t->centerOn((*reinterpret_cast<std::add_pointer_t<GeoDataPlacemark>>(_a[1]))); break;
        case 49: _t->centerOn((*reinterpret_cast<std::add_pointer_t<GeoDataLatLonBox>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 50: _t->centerOn((*reinterpret_cast<std::add_pointer_t<GeoDataLatLonBox>>(_a[1]))); break;
        case 51: _t->centerOn((*reinterpret_cast<std::add_pointer_t<GeoDataCoordinates>>(_a[1]))); break;
        case 52: _t->centerOn((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2]))); break;
        case 53: _t->centerOnCoordinates((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2]))); break;
        case 54: _t->centerOnCurrentPosition(); break;
        case 55: _t->selectPlacemarkAt((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 56: _t->zoomIn((*reinterpret_cast<std::add_pointer_t<FlyToMode>>(_a[1]))); break;
        case 57: _t->zoomIn(); break;
        case 58: _t->zoomOut((*reinterpret_cast<std::add_pointer_t<FlyToMode>>(_a[1]))); break;
        case 59: _t->zoomOut(); break;
        case 60: _t->handlePinchStarted((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 61: _t->handlePinchFinished((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1]))); break;
        case 62: _t->handlePinchUpdated((*reinterpret_cast<std::add_pointer_t<QPointF>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qreal>>(_a[2]))); break;
        case 63: _t->setMapWidth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 64: _t->setMapHeight((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 65: _t->setShowFrameRate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 66: _t->setProjection((*reinterpret_cast<std::add_pointer_t<enum Projection>>(_a[1]))); break;
        case 67: _t->setMapThemeId((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 68: _t->setShowAtmosphere((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 69: _t->setShowCompass((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 70: _t->setShowClouds((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 71: _t->setShowCrosshairs((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 72: _t->setShowGrid((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 73: _t->setShowOverviewMap((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 74: _t->setShowOtherPlaces((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 75: _t->setShowScaleBar((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 76: _t->setShowBackground((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 77: _t->setShowPositionMarker((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 78: _t->setShowPublicTransport((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 79: _t->setShowOutdoorActivities((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 80: _t->setPositionProvider((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 81: _t->setInertialGlobeRotation((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 82: _t->setAnimationViewContext((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 83: _t->setAnimationsEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 84: _t->setPluginSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 85: _t->setPropertyEnabled((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 86: { bool _r = _t->isPropertyEnabled((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 87: _t->setWorkOffline((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 88: _t->setInvertColorEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 89: _t->setInvertColorEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 90: _t->setShowRuntimeTrace((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 91: _t->setShowDebugPolygons((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 92: _t->setShowDebugPlacemarks((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 93: _t->setShowDebugBatches((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 94: _t->setPlacemarkDelegate((*reinterpret_cast<std::add_pointer_t<QQmlComponent*>>(_a[1]))); break;
        case 95: _t->loadSettings(); break;
        case 96: _t->writeSettings(); break;
        case 97: _t->reloadTiles(); break;
        case 98: _t->highlightRouteRelation((*reinterpret_cast<std::add_pointer_t<qint64>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 99: _t->setRelationTypeVisible((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 100: { bool _r = _t->isRelationTypeVisible((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 101: _t->setHeading((*reinterpret_cast<std::add_pointer_t<qreal>>(_a[1]))); break;
        case 102: _t->setHoverEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 103: { qreal _r = _t->centerLongitude();
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 104: { qreal _r = _t->centerLatitude();
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 105: _t->resizeMap(); break;
        case 106: _t->positionDataStatusChanged((*reinterpret_cast<std::add_pointer_t<PositionProviderStatus>>(_a[1]))); break;
        case 107: _t->positionChanged((*reinterpret_cast<std::add_pointer_t<GeoDataCoordinates>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<GeoDataAccuracy>>(_a[2]))); break;
        case 108: _t->updatePositionVisibility(); break;
        case 109: _t->updateCurrentPosition((*reinterpret_cast<std::add_pointer_t<GeoDataCoordinates>>(_a[1]))); break;
        case 110: _t->updatePlacemarks(); break;
        case 111: _t->handleReverseGeocoding((*reinterpret_cast<std::add_pointer_t<GeoDataCoordinates>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<GeoDataPlacemark>>(_a[2]))); break;
        case 112: _t->handleVisibleLatLonAltBoxChanged((*reinterpret_cast<std::add_pointer_t<GeoDataLatLonAltBox>>(_a[1]))); break;
        case 113: { qreal _r = _t->distanceFromPointToCurrentLocation((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 114: { qreal _r = _t->angleFromPointToCurrentLocation((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<qreal*>(_a[0]) = std::move(_r); }  break;
        case 115: { QPointF _r = _t->screenCoordinatesFromCoordinate((*reinterpret_cast<std::add_pointer_t<Coordinate*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 116: { QPointF _r = _t->screenCoordinatesFromGeoDataCoordinates((*reinterpret_cast<std::add_pointer_t<GeoDataCoordinates>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QPointF*>(_a[0]) = std::move(_r); }  break;
        case 117: { bool _r = _t->screenCoordinatesToCoordinate((*reinterpret_cast<std::add_pointer_t<QPoint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Coordinate*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 118: { bool _r = _t->invertColorEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 119: _t->moveUp(); break;
        case 120: _t->moveDown(); break;
        case 121: _t->moveLeft(); break;
        case 122: _t->moveRight(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Placemark* >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQmlComponent* >(); break;
            }
            break;
        case 94:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQmlComponent* >(); break;
            }
            break;
        case 115:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Coordinate* >(); break;
            }
            break;
        case 117:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Coordinate* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(int )>(_a, &MarbleQuickItem::mapWidthChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(int )>(_a, &MarbleQuickItem::mapHeightChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showFrameRateChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(Projection )>(_a, &MarbleQuickItem::projectionChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(const QString & )>(_a, &MarbleQuickItem::mapThemeIdChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::mapThemeChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showAtmosphereChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showCompassChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showCloudsChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showCrosshairsChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showGridChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showOverviewMapChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showOtherPlacesChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showScaleBarChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showBackgroundChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showPositionMarkerChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showPublicTransportChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::showOutdoorActivitiesChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(const QString & )>(_a, &MarbleQuickItem::positionProviderChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::positionAvailableChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::positionVisibleChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::marbleMapChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::visibleLatLonAltBoxChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(Placemark * )>(_a, &MarbleQuickItem::currentPositionChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::angleChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::speedChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(qreal )>(_a, &MarbleQuickItem::headingChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::zoomChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(int )>(_a, &MarbleQuickItem::radiusChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::inertialGlobeRotationChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::animationViewContextChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(QQmlComponent * )>(_a, &MarbleQuickItem::placemarkDelegateChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::animationsEnabledChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::hoverEnabledChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(const QPoint & )>(_a, &MarbleQuickItem::lmbMenuRequested, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(const QPoint & )>(_a, &MarbleQuickItem::rmbMenuRequested, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(const QPoint & )>(_a, &MarbleQuickItem::hoverPositionChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(int )>(_a, &MarbleQuickItem::minimumZoomChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(int )>(_a, &MarbleQuickItem::maximumZoomChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)(bool )>(_a, &MarbleQuickItem::invertColorEnabledChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::workOfflineChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (MarbleQuickItem::*)()>(_a, &MarbleQuickItem::geoItemUpdateRequested, 41))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 9:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Marble::MapTheme* >(); break;
        case 26:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< MarbleMap* >(); break;
        case 27:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Placemark* >(); break;
        case 33:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QQmlComponent* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->mapWidth(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->mapHeight(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->zoom(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->minimumZoom(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->maximumZoom(); break;
        case 5: *reinterpret_cast<int*>(_v) = _t->radius(); break;
        case 6: *reinterpret_cast<qreal*>(_v) = _t->heading(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->showFrameRate(); break;
        case 8: *reinterpret_cast<enum Projection*>(_v) = _t->projection(); break;
        case 9: *reinterpret_cast<Marble::MapTheme**>(_v) = _t->mapTheme(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->mapThemeId(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->showAtmosphere(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->showCompass(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->showClouds(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->showCrosshairs(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->showGrid(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->showOverviewMap(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->showOtherPlaces(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->showScaleBar(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->showBackground(); break;
        case 20: *reinterpret_cast<bool*>(_v) = _t->showPositionMarker(); break;
        case 21: *reinterpret_cast<bool*>(_v) = _t->showPublicTransport(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->showOutdoorActivities(); break;
        case 23: *reinterpret_cast<QString*>(_v) = _t->positionProvider(); break;
        case 24: *reinterpret_cast<bool*>(_v) = _t->positionAvailable(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->positionVisible(); break;
        case 26: *reinterpret_cast<MarbleMap**>(_v) = _t->map(); break;
        case 27: *reinterpret_cast<Placemark**>(_v) = _t->currentPosition(); break;
        case 28: *reinterpret_cast<qreal*>(_v) = _t->speed(); break;
        case 29: *reinterpret_cast<qreal*>(_v) = _t->angle(); break;
        case 30: *reinterpret_cast<bool*>(_v) = _t->inertialGlobeRotation(); break;
        case 31: *reinterpret_cast<bool*>(_v) = _t->animationViewContext(); break;
        case 32: *reinterpret_cast<bool*>(_v) = _t->animationsEnabled(); break;
        case 33: *reinterpret_cast<QQmlComponent**>(_v) = _t->placemarkDelegate(); break;
        case 34: *reinterpret_cast<bool*>(_v) = _t->hoverEnabled(); break;
        case 35: *reinterpret_cast<bool*>(_v) = _t->invertColorEnabled(); break;
        case 36: *reinterpret_cast<bool*>(_v) = _t->workOffline(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setMapWidth(*reinterpret_cast<int*>(_v)); break;
        case 1: _t->setMapHeight(*reinterpret_cast<int*>(_v)); break;
        case 2: _t->setZoom(*reinterpret_cast<int*>(_v)); break;
        case 5: _t->setRadius(*reinterpret_cast<int*>(_v)); break;
        case 6: _t->setHeading(*reinterpret_cast<qreal*>(_v)); break;
        case 7: _t->setShowFrameRate(*reinterpret_cast<bool*>(_v)); break;
        case 8: _t->setProjection(*reinterpret_cast<enum Projection*>(_v)); break;
        case 10: _t->setMapThemeId(*reinterpret_cast<QString*>(_v)); break;
        case 11: _t->setShowAtmosphere(*reinterpret_cast<bool*>(_v)); break;
        case 12: _t->setShowCompass(*reinterpret_cast<bool*>(_v)); break;
        case 13: _t->setShowClouds(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setShowCrosshairs(*reinterpret_cast<bool*>(_v)); break;
        case 15: _t->setShowGrid(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->setShowOverviewMap(*reinterpret_cast<bool*>(_v)); break;
        case 17: _t->setShowOtherPlaces(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setShowScaleBar(*reinterpret_cast<bool*>(_v)); break;
        case 19: _t->setShowBackground(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setShowPositionMarker(*reinterpret_cast<bool*>(_v)); break;
        case 21: _t->setShowPublicTransport(*reinterpret_cast<bool*>(_v)); break;
        case 22: _t->setShowOutdoorActivities(*reinterpret_cast<bool*>(_v)); break;
        case 23: _t->setPositionProvider(*reinterpret_cast<QString*>(_v)); break;
        case 30: _t->setInertialGlobeRotation(*reinterpret_cast<bool*>(_v)); break;
        case 31: _t->setAnimationViewContext(*reinterpret_cast<bool*>(_v)); break;
        case 32: _t->setAnimationsEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 33: _t->setPlacemarkDelegate(*reinterpret_cast<QQmlComponent**>(_v)); break;
        case 34: _t->setHoverEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 35: _t->setInvertColorEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 36: _t->setWorkOffline(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

void *Marble::MarbleQuickItem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Marble15MarbleQuickItemE_t>.strings))
        return static_cast<void*>(this);
    return QQuickPaintedItem::qt_metacast(_clname);
}

int Marble::MarbleQuickItem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QQuickPaintedItem::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 123)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 123;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 123)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 123;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 37;
    }
    return _id;
}

// SIGNAL 0
void Marble::MarbleQuickItem::mapWidthChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Marble::MarbleQuickItem::mapHeightChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

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

// SIGNAL 3
void Marble::MarbleQuickItem::projectionChanged(Projection _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

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

// SIGNAL 5
void Marble::MarbleQuickItem::mapThemeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

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

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

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

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

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

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

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

// SIGNAL 13
void Marble::MarbleQuickItem::showScaleBarChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Marble::MarbleQuickItem::showBackgroundChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

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

// SIGNAL 16
void Marble::MarbleQuickItem::showPublicTransportChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void Marble::MarbleQuickItem::showOutdoorActivitiesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void Marble::MarbleQuickItem::positionProviderChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void Marble::MarbleQuickItem::positionAvailableChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void Marble::MarbleQuickItem::positionVisibleChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void Marble::MarbleQuickItem::marbleMapChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void Marble::MarbleQuickItem::visibleLatLonAltBoxChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void Marble::MarbleQuickItem::currentPositionChanged(Placemark * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void Marble::MarbleQuickItem::angleChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void Marble::MarbleQuickItem::speedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void Marble::MarbleQuickItem::headingChanged(qreal _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void Marble::MarbleQuickItem::zoomChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void Marble::MarbleQuickItem::radiusChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void Marble::MarbleQuickItem::inertialGlobeRotationChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void Marble::MarbleQuickItem::animationViewContextChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void Marble::MarbleQuickItem::placemarkDelegateChanged(QQmlComponent * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void Marble::MarbleQuickItem::animationsEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void Marble::MarbleQuickItem::hoverEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void Marble::MarbleQuickItem::lmbMenuRequested(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void Marble::MarbleQuickItem::rmbMenuRequested(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void Marble::MarbleQuickItem::hoverPositionChanged(const QPoint & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void Marble::MarbleQuickItem::minimumZoomChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void Marble::MarbleQuickItem::maximumZoomChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void Marble::MarbleQuickItem::invertColorEnabledChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void Marble::MarbleQuickItem::workOfflineChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 40, nullptr);
}

// SIGNAL 41
void Marble::MarbleQuickItem::geoItemUpdateRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 41, nullptr);
}
QT_WARNING_POP
