File indexing completed on 2024-04-28 07:37:59

 // SPDX-License-Identifier: LGPL-2.1-or-later
 //
 // SPDX-FileCopyrightText: 2006-2009 Torsten Rahn <tackat@kde.org>
 // SPDX-FileCopyrightText: 2007 Inge Wallin <ingwa@kde.org>
 // SPDX-FileCopyrightText: 2008 Carlos Licea <carlos.licea@kdemail.net>
 // SPDX-FileCopyrightText: 2009 Jens-Michael Hoffmann <jensmh@gmx.de>
 // SPDX-FileCopyrightText: 2010-2012 Bernhard Beschow <bbeschow@cs.tu-berlin.de>
 //
 
 
 // Own
 #include "MarbleMap.h"
 
 // Posix
 #include <cmath>
 
 // Qt
 #include <QElapsedTimer>
 #include <QtMath>
 
 // Marble
 #include "layers/FloatItemsLayer.h"
 #include "layers/FogLayer.h"
 #include "layers/FpsLayer.h"
 #include "layers/GeometryLayer.h"
 #include "layers/GroundLayer.h"
 #include "layers/MarbleSplashLayer.h"
 #include "layers/PlacemarkLayer.h"
 #include "layers/TextureLayer.h"
 #include "layers/VectorTileLayer.h"
 #include "AbstractFloatItem.h"
 #include "DgmlAuxillaryDictionary.h"
 #include "FileManager.h"
 #include "GeoDataTreeModel.h"
 #include "GeoPainter.h"
 #include "GeoSceneDocument.h"
 #include "GeoSceneFilter.h"
 #include "GeoSceneGeodata.h"
 #include "GeoSceneHead.h"
 #include "GeoSceneLayer.h"
 #include "GeoSceneMap.h"
 #include "GeoScenePalette.h"
 #include "GeoSceneSettings.h"
 #include "GeoSceneVector.h"
 #include "GeoSceneVectorTileDataset.h"
 #include "GeoSceneTextureTileDataset.h"
 #include "GeoSceneZoom.h"
 #include "GeoDataDocument.h"
 #include "GeoDataFeature.h"
 #include "GeoDataStyle.h"
 #include "GeoDataStyleMap.h"
 #include "LayerManager.h"
 #include "MapThemeManager.h"
 #include "MarbleDebug.h"
 #include "MarbleDirs.h"
 #include "MarbleModel.h"
 #include "PluginManager.h"
 #include "RenderPlugin.h"
 #include "StyleBuilder.h"
 #include "SunLocator.h"
 #include "TileId.h"
 #include "TileCoordsPyramid.h"
 #include "TileCreator.h"
 #include "TileCreatorDialog.h"
 #include "TileLoader.h"
 #include "ViewParams.h"
 #include "ViewportParams.h"
 #include "RenderState.h"
 #include "BookmarkManager.h"
 
 
 namespace Marble
 {
 
 
 class MarbleMap::CustomPaintLayer : public LayerInterface
 {
 public:
     explicit CustomPaintLayer( MarbleMap *map )
         : m_map( map )
     {
     }
 
     QStringList renderPosition() const override { return QStringList() << "USER_TOOLS"; }
 
     bool render( GeoPainter *painter, ViewportParams *viewport,
                          const QString &renderPos, GeoSceneLayer *layer ) override
     {
         Q_UNUSED( viewport );
         Q_UNUSED( renderPos );
         Q_UNUSED( layer );
 
         m_map->customPaint( painter );
 
         return true;
     }
 
     qreal zValue() const override { return 1.0e6; }
 
     RenderState renderState() const override { return RenderState(QStringLiteral("Custom Map Paint")); }
 
     QString runtimeTrace() const override { return QStringLiteral("CustomPaint"); }
 
 private:
     MarbleMap *const m_map;
 };
 
 
 class MarbleMapPrivate
 {
     friend class MarbleWidget;
 
 public:
     explicit MarbleMapPrivate( MarbleMap *parent, MarbleModel *model );
 
     void updateMapTheme();
 
     void updateProperty( const QString &, bool );
 
     void setDocument( const QString& key );
 
     void updateTileLevel();
 
     void addPlugins();
 
     MarbleMap *const q;
 
     // The model we are showing.
     MarbleModel     *const m_model;
     bool             m_modelIsOwned;
 
     // Parameters for the maps appearance.
     ViewParams       m_viewParams;
     ViewportParams   m_viewport;
     bool             m_showFrameRate;
     bool             m_showDebugPolygons;
     bool             m_showDebugBatchRender;
     GeoDataRelation::RelationTypes m_visibleRelationTypes;
     StyleBuilder     m_styleBuilder;
 
     QList<RenderPlugin *> m_renderPlugins;
 
     LayerManager     m_layerManager;
     MarbleSplashLayer m_marbleSplashLayer;
     MarbleMap::CustomPaintLayer m_customPaintLayer;
     GeometryLayer            m_geometryLayer;
     FloatItemsLayer          m_floatItemsLayer;
     FogLayer                 m_fogLayer;
     GroundLayer              m_groundLayer;
     TextureLayer     m_textureLayer;
     PlacemarkLayer   m_placemarkLayer;
     VectorTileLayer  m_vectorTileLayer;
 
     bool m_isLockedToSubSolarPoint;
     bool m_isSubSolarPointIconVisible;
     RenderState m_renderState;
 };
 
 MarbleMapPrivate::MarbleMapPrivate( MarbleMap *parent, MarbleModel *model ) :
     q( parent ),
     m_model( model ),
     m_viewParams(),
     m_showFrameRate( false ),
     m_showDebugPolygons( false ),
     m_showDebugBatchRender( false ),
     m_visibleRelationTypes(GeoDataRelation::RouteFerry),
     m_styleBuilder(),
     m_layerManager( parent ),
     m_customPaintLayer( parent ),
     m_geometryLayer(model->treeModel(), &m_styleBuilder),
     m_floatItemsLayer(parent),
     m_textureLayer( model->downloadManager(), model->pluginManager(), model->sunLocator(), model->groundOverlayModel() ),
     m_placemarkLayer( model->placemarkModel(), model->placemarkSelectionModel(), model->clock(), &m_styleBuilder ),
     m_vectorTileLayer( model->downloadManager(), model->pluginManager(), model->treeModel() ),
     m_isLockedToSubSolarPoint( false ),
     m_isSubSolarPointIconVisible( false )
 {
     m_layerManager.addLayer(&m_floatItemsLayer);
     m_layerManager.addLayer( &m_fogLayer );
     m_layerManager.addLayer( &m_groundLayer );
     m_layerManager.addLayer( &m_geometryLayer );
     m_layerManager.addLayer( &m_placemarkLayer );
     m_layerManager.addLayer( &m_customPaintLayer );
 
     m_model->bookmarkManager()->setStyleBuilder(&m_styleBuilder);
 
     QObject::connect( m_model, SIGNAL(themeChanged(QString)),
                       parent, SLOT(updateMapTheme()) );
     QObject::connect( m_model->fileManager(), SIGNAL(fileAdded(QString)),
                       parent, SLOT(setDocument(QString)) );
 
 
     QObject::connect( &m_placemarkLayer, SIGNAL(repaintNeeded()),
                       parent, SIGNAL(repaintNeeded()));
 
     QObject::connect ( &m_layerManager, SIGNAL(pluginSettingsChanged()),
                        parent,        SIGNAL(pluginSettingsChanged()) );
     QObject::connect ( &m_layerManager, SIGNAL(repaintNeeded(QRegion)),
                        parent,        SIGNAL(repaintNeeded(QRegion)) );
     QObject::connect ( &m_layerManager, SIGNAL(renderPluginInitialized(RenderPlugin*)),
                        parent,        SIGNAL(renderPluginInitialized(RenderPlugin*)) );
     QObject::connect ( &m_layerManager, SIGNAL(visibilityChanged(QString,bool)),
                        parent,        SLOT(setPropertyValue(QString,bool)) );
 
     QObject::connect( &m_geometryLayer, SIGNAL(repaintNeeded()),
                       parent, SIGNAL(repaintNeeded()));
 
     /*
      * Slot handleHighlight finds all placemarks
      * that contain the clicked point.
      * The placemarks under the clicked position may
      * have their styleUrl set to a style map which
      * doesn't specify any highlight styleId. Such
      * placemarks will be fletered out in GeoGraphicsScene
      * and will not be highlighted.
      */
     QObject::connect( parent, SIGNAL(highlightedPlacemarksChanged(qreal,qreal,GeoDataCoordinates::Unit)),
                       &m_geometryLayer, SLOT(handleHighlight(qreal,qreal,GeoDataCoordinates::Unit)) );
 
     QObject::connect(&m_floatItemsLayer, SIGNAL(repaintNeeded(QRegion)),
                      parent,             SIGNAL(repaintNeeded(QRegion)));
     QObject::connect(&m_floatItemsLayer, SIGNAL(renderPluginInitialized(RenderPlugin*)),
                      parent,             SIGNAL(renderPluginInitialized(RenderPlugin*)));
     QObject::connect(&m_floatItemsLayer, SIGNAL(visibilityChanged(QString,bool)),
                      parent,             SLOT(setPropertyValue(QString,bool)));
     QObject::connect(&m_floatItemsLayer, SIGNAL(pluginSettingsChanged()),
                      parent,             SIGNAL(pluginSettingsChanged()));
 
     QObject::connect( &m_textureLayer, SIGNAL(tileLevelChanged(int)),
                       parent, SLOT(updateTileLevel()) );
     QObject::connect( &m_vectorTileLayer, SIGNAL(tileLevelChanged(int)),
                       parent, SLOT(updateTileLevel()) );
     QObject::connect( parent, SIGNAL(radiusChanged(int)),
                       parent, SLOT(updateTileLevel()) );
 
     QObject::connect( &m_textureLayer, SIGNAL(repaintNeeded()),
                       parent, SIGNAL(repaintNeeded()) );
     QObject::connect( parent, SIGNAL(visibleLatLonAltBoxChanged(GeoDataLatLonAltBox)),
                       parent, SIGNAL(repaintNeeded()) );
 
     addPlugins();
     QObject::connect(model->pluginManager(), SIGNAL(renderPluginsChanged()),
                      parent, SLOT(addPlugins()));
 }
 
 void MarbleMapPrivate::updateProperty( const QString &name, bool show )
 {
     // earth
     if (name == QLatin1String("places")) {
         m_placemarkLayer.setShowPlaces( show );
     } else if (name == QLatin1String("cities")) {
         m_placemarkLayer.setShowCities( show );
     } else if (name == QLatin1String("terrain")) {
         m_placemarkLayer.setShowTerrain( show );
     } else if (name == QLatin1String("otherplaces")) {
         m_placemarkLayer.setShowOtherPlaces( show );
     }
 
     // other planets
     else if (name == QLatin1String("landingsites")) {
         m_placemarkLayer.setShowLandingSites( show );
     } else if (name == QLatin1String("craters")) {
         m_placemarkLayer.setShowCraters( show );
     } else if (name == QLatin1String("maria")) {
         m_placemarkLayer.setShowMaria( show );
     }
 
     else if (name == QLatin1String("relief")) {
         m_textureLayer.setShowRelief( show );
     }
 
     for(RenderPlugin *renderPlugin: m_renderPlugins) {
         if ( name == renderPlugin->nameId() ) {
             if ( renderPlugin->visible() == show ) {
                 break;
             }
 
             renderPlugin->setVisible( show );
 
             break;
         }
     }
 }
 
 void MarbleMapPrivate::addPlugins()
 {
     for (const RenderPlugin *factory: m_model->pluginManager()->renderPlugins()) {
         bool alreadyCreated = false;
         for(const RenderPlugin *existing: m_renderPlugins) {
             if (existing->nameId() == factory->nameId()) {
                 alreadyCreated = true;
                 break;
             }
         }
 
         if (alreadyCreated) {
             continue;
         }
 
         RenderPlugin *const renderPlugin = factory->newInstance(m_model);
         Q_ASSERT(renderPlugin && "Plugin must not return null when requesting a new instance.");
         m_renderPlugins << renderPlugin;
 
         if (AbstractFloatItem *const floatItem = qobject_cast<AbstractFloatItem *>(renderPlugin)) {
             m_floatItemsLayer.addFloatItem(floatItem);
         }
         else {
             m_layerManager.addRenderPlugin(renderPlugin);
         }
     }
 }
 
 // ----------------------------------------------------------------
 
 
 MarbleMap::MarbleMap()
     : d( new MarbleMapPrivate( this, new MarbleModel( this ) ) )
 {
     // nothing to do
 }
 
 MarbleMap::MarbleMap(MarbleModel *model)
     : d( new MarbleMapPrivate( this, model ) )
 {
     d->m_modelIsOwned = false;
 }
 
 MarbleMap::~MarbleMap()
 {
     MarbleModel *model = d->m_modelIsOwned ? d->m_model : nullptr;
 
     d->m_layerManager.removeLayer( &d->m_customPaintLayer );
     d->m_layerManager.removeLayer( &d->m_geometryLayer );
     d->m_layerManager.removeLayer(&d->m_floatItemsLayer);
     d->m_layerManager.removeLayer( &d->m_fogLayer );
     d->m_layerManager.removeLayer( &d->m_placemarkLayer );
     d->m_layerManager.removeLayer( &d->m_textureLayer );
     d->m_layerManager.removeLayer( &d->m_groundLayer );
     qDeleteAll(d->m_renderPlugins);
     delete d;
 
     delete model;  // delete the model after private data
 }
 
 MarbleModel *MarbleMap::model() const
 {
     return d->m_model;
 }
 
 ViewportParams *MarbleMap::viewport()
 {
     return &d->m_viewport;
 }
 
 const ViewportParams *MarbleMap::viewport() const
 {
     return &d->m_viewport;
 }
 
 
 void MarbleMap::setMapQualityForViewContext( MapQuality quality, ViewContext viewContext )
 {
     d->m_viewParams.setMapQualityForViewContext( quality, viewContext );
 
     // Update texture map during the repaint that follows:
     d->m_textureLayer.setNeedsUpdate();
 }
 
 MapQuality MarbleMap::mapQuality( ViewContext viewContext ) const
 {
     return d->m_viewParams.mapQuality( viewContext );
 }
 
 MapQuality MarbleMap::mapQuality() const
 {
     return d->m_viewParams.mapQuality();
 }
 
 void MarbleMap::setViewContext( ViewContext viewContext )
 {
     if ( d->m_viewParams.viewContext() == viewContext ) {
         return;
     }
 
     const MapQuality oldQuality = d->m_viewParams.mapQuality();
     d->m_viewParams.setViewContext( viewContext );
     emit viewContextChanged( viewContext );
 
     if ( d->m_viewParams.mapQuality() != oldQuality ) {
         // Update texture map during the repaint that follows:
         d->m_textureLayer.setNeedsUpdate();
 
         emit repaintNeeded();
     }
 }
 
 ViewContext MarbleMap::viewContext() const
 {
     return d->m_viewParams.viewContext();
 }
 
 
 void MarbleMap::setSize( int width, int height )
 {
     setSize( QSize( width, height ) );
 }
 
 void MarbleMap::setSize( const QSize& size )
 {
     d->m_viewport.setSize( size );
 
     emit visibleLatLonAltBoxChanged( d->m_viewport.viewLatLonAltBox() );
 }
 
 QSize MarbleMap::size() const
 {
     return QSize( d->m_viewport.width(), d->m_viewport.height() );
 }
 
 int  MarbleMap::width() const
 {
     return d->m_viewport.width();
 }
 
 int  MarbleMap::height() const
 {
     return d->m_viewport.height();
 }
 
 int MarbleMap::radius() const
 {
     return d->m_viewport.radius();
 }
 
 void MarbleMap::setRadius( int radius )
 {
     const int oldRadius = d->m_viewport.radius();
 
     d->m_viewport.setRadius( radius );
 
     if ( oldRadius != d->m_viewport.radius() ) {
         emit radiusChanged( radius );
         emit visibleLatLonAltBoxChanged( d->m_viewport.viewLatLonAltBox() );
     }
 }
 
 
 int MarbleMap::preferredRadiusCeil(int radius) const
 {
     return d->m_textureLayer.preferredRadiusCeil( radius );
 }
 
 
 int MarbleMap::preferredRadiusFloor(int radius) const
 {
     return d->m_textureLayer.preferredRadiusFloor( radius );
 }
 
 
 int MarbleMap::tileZoomLevel() const
 {
     auto const tileZoomLevel = qMax(d->m_textureLayer.tileZoomLevel(), d->m_vectorTileLayer.tileZoomLevel());
     return tileZoomLevel >= 0 ? tileZoomLevel : qMin<int>(qMax<int>(qLn(d->m_viewport.radius()*4/256)/qLn(2.0), 1), d->m_styleBuilder.maximumZoomLevel());
 }
 
 
 qreal MarbleMap::centerLatitude() const
 {
     // Calculate translation of center point
     const qreal centerLat = d->m_viewport.centerLatitude();
 
     return centerLat * RAD2DEG;
 }
 
 bool MarbleMap::hasFeatureAt(const QPoint &position) const
 {
     return d->m_placemarkLayer.hasPlacemarkAt(position) || d->m_geometryLayer.hasFeatureAt(position, viewport());
 }
 
 qreal MarbleMap::centerLongitude() const
 {
     // Calculate translation of center point
     const qreal centerLon = d->m_viewport.centerLongitude();
 
     return centerLon * RAD2DEG;
 }
 
 int  MarbleMap::minimumZoom() const
 {
     if ( d->m_model->mapTheme() )
         return d->m_model->mapTheme()->head()->zoom()->minimum();
 
     return 950;
 }
 
 int  MarbleMap::maximumZoom() const
 {
     if ( d->m_model->mapTheme() )
         return d->m_model->mapTheme()->head()->zoom()->maximum();
 
     return 2100;
 }
 
 bool MarbleMap::discreteZoom() const
 {
     if ( d->m_model->mapTheme() )
         return d->m_model->mapTheme()->head()->zoom()->discrete();
 
     return false;
 }
 
 QVector<const GeoDataFeature*> MarbleMap::whichFeatureAt( const QPoint& curpos ) const
 {
     return d->m_placemarkLayer.whichPlacemarkAt( curpos ) + d->m_geometryLayer.whichFeatureAt( curpos, viewport() );
 }
 
 void MarbleMap::reload()
 {
     d->m_textureLayer.reload();
     d->m_vectorTileLayer.reload();
 }
 
 void MarbleMap::downloadRegion( QVector<TileCoordsPyramid> const & pyramid )
 {
     Q_ASSERT( textureLayer() );
     Q_ASSERT( !pyramid.isEmpty() );
     QElapsedTimer t;
     t.start();
 
     // When downloading a region (the author of these lines thinks) most users probably expect
     // the download to begin with the low resolution tiles and then procede level-wise to
     // higher resolution tiles. In order to achieve this, we start requesting downloads of
     // high resolution tiles and request the low resolution tiles at the end because
     // DownloadQueueSet (silly name) is implemented as stack.
 
 
     int const first = 0;
     int tilesCount = 0;
 
     for ( int level = pyramid[first].bottomLevel(); level >= pyramid[first].topLevel(); --level ) {
         QSet<TileId> tileIdSet;
         for( int i = 0; i < pyramid.size(); ++i ) {
             QRect const coords = pyramid[i].coords( level );
             mDebug() << "MarbleMap::downloadRegion level:" << level << "tile coords:" << coords;
             int x1, y1, x2, y2;
             coords.getCoords( &x1, &y1, &x2, &y2 );
             for ( int x = x1; x <= x2; ++x ) {
                 for ( int y = y1; y <= y2; ++y ) {
                     TileId const stackedTileId( 0, level, x, y );
                     tileIdSet.insert( stackedTileId );
                     // FIXME: use lazy evaluation to not generate up to 100k tiles in one go
                     // this can take considerable time even on very fast systems
                     // in contrast generating the TileIds on the fly when they are needed
                     // does not seem to affect download speed.
                 }
             }
         }
         QSetIterator<TileId> i( tileIdSet );
         while( i.hasNext() ) {
             TileId const tileId = i.next();
             d->m_textureLayer.downloadStackedTile( tileId );
             d->m_vectorTileLayer.downloadTile(tileId);
             mDebug() << "TileDownload" << tileId;
         }
         tilesCount += tileIdSet.count();
     }
     // Needed for downloading unique tiles only. Much faster than if tiles for each level is downloaded separately
 
     int const elapsedMs = t.elapsed();
     mDebug() << "MarbleMap::downloadRegion:" << tilesCount << "tiles, " << elapsedMs << "ms";
 }
 
 void MarbleMap::highlightRouteRelation(qint64 osmId, bool enabled)
 {
     d->m_geometryLayer.highlightRouteRelation(osmId, enabled);
 }
 
 bool MarbleMap::propertyValue( const QString& name ) const
 {
     bool value;
     if ( d->m_model->mapTheme() ) {
         d->m_model->mapTheme()->settings()->propertyValue( name, value );
     }
     else {
         value = false;
         mDebug() << "WARNING: Failed to access a map theme! Property: " << name;
     }
     return value;
 }
 
 bool MarbleMap::showOverviewMap() const
 {
     return propertyValue(QStringLiteral("overviewmap"));
 }
 
 bool MarbleMap::showScaleBar() const
 {
     return propertyValue(QStringLiteral("scalebar"));
 }
 
 bool MarbleMap::showCompass() const
 {
     return propertyValue(QStringLiteral("compass"));
 }
 
 bool MarbleMap::showGrid() const
 {
     return propertyValue(QStringLiteral("coordinate-grid"));
 }
 
 bool MarbleMap::showClouds() const
 {
     return d->m_viewParams.showClouds();
 }
 
 bool MarbleMap::showSunShading() const
 {
     return d->m_textureLayer.showSunShading();
 }
 
 bool MarbleMap::showCityLights() const
 {
     return d->m_textureLayer.showCityLights();
 }
 
 bool MarbleMap::isLockedToSubSolarPoint() const
 {
     return d->m_isLockedToSubSolarPoint;
 }
 
 bool MarbleMap::isSubSolarPointIconVisible() const
 {
     return d->m_isSubSolarPointIconVisible;
 }
 
 bool MarbleMap::showAtmosphere() const
 {
     return d->m_viewParams.showAtmosphere();
 }
 
 bool MarbleMap::showCrosshairs() const
 {
     bool visible = false;
 
     QList<RenderPlugin *> pluginList = renderPlugins();
     QList<RenderPlugin *>::const_iterator i = pluginList.constBegin();
     QList<RenderPlugin *>::const_iterator const end = pluginList.constEnd();
     for (; i != end; ++i ) {
         if ((*i)->nameId() == QLatin1String("crosshairs")) {
             visible = (*i)->visible();
         }
     }
 
     return visible;
 }
 
 bool MarbleMap::showPlaces() const
 {
     return propertyValue(QStringLiteral("places"));
 }
 
 bool MarbleMap::showCities() const
 {
     return propertyValue(QStringLiteral("cities"));
 }
 
 bool MarbleMap::showTerrain() const
 {
     return propertyValue(QStringLiteral("terrain"));
 }
 
 bool MarbleMap::showOtherPlaces() const
 {
     return propertyValue(QStringLiteral("otherplaces"));
 }
 
 bool MarbleMap::showRelief() const
 {
     return propertyValue(QStringLiteral("relief"));
 }
 
 bool MarbleMap::showIceLayer() const
 {
     return propertyValue(QStringLiteral("ice"));
 }
 
 bool MarbleMap::showBorders() const
 {
     return propertyValue(QStringLiteral("borders"));
 }
 
 bool MarbleMap::showRivers() const
 {
     return propertyValue(QStringLiteral("rivers"));
 }
 
 bool MarbleMap::showLakes() const
 {
     return propertyValue(QStringLiteral("lakes"));
 }
 
 bool MarbleMap::showFrameRate() const
 {
     return d->m_showFrameRate;
 }
 
 bool MarbleMap::showBackground() const
 {
     return d->m_layerManager.showBackground();
 }
 
 GeoDataRelation::RelationTypes MarbleMap::visibleRelationTypes() const
 {
     return d->m_visibleRelationTypes;
 }
 
 quint64 MarbleMap::volatileTileCacheLimit() const
 {
     return d->m_textureLayer.volatileCacheLimit();
 }
 
 
 void MarbleMap::rotateBy(qreal deltaLon, qreal deltaLat)
 {
     centerOn( d->m_viewport.centerLongitude() * RAD2DEG + deltaLon,
               d->m_viewport.centerLatitude()  * RAD2DEG + deltaLat );
 }
 
 
 void MarbleMap::centerOn( const qreal lon, const qreal lat )
 {
     d->m_viewport.centerOn( lon * DEG2RAD, lat * DEG2RAD );
 
     emit visibleLatLonAltBoxChanged( d->m_viewport.viewLatLonAltBox() );
 }
 
 void MarbleMap::setCenterLatitude( qreal lat )
 {
     centerOn( centerLongitude(), lat );
 }
 
 void MarbleMap::setCenterLongitude( qreal lon )
 {
     centerOn( lon, centerLatitude() );
 }
 
 Projection MarbleMap::projection() const
 {
     return d->m_viewport.projection();
 }
 
 void MarbleMap::setProjection( Projection projection )
 {
     if ( d->m_viewport.projection() == projection )
         return;
 
     emit projectionChanged( projection );
 
     d->m_viewport.setProjection( projection );
 
     d->m_textureLayer.setProjection( projection );
 
     emit visibleLatLonAltBoxChanged( d->m_viewport.viewLatLonAltBox() );
 }
 
 
 bool MarbleMap::screenCoordinates( qreal lon, qreal lat,
                                    qreal& x, qreal& y ) const
 {
     return d->m_viewport.screenCoordinates( lon * DEG2RAD, lat * DEG2RAD, x, y );
 }
 
 bool MarbleMap::geoCoordinates( int x, int y,
                                 qreal& lon, qreal& lat,
                                 GeoDataCoordinates::Unit unit ) const
 {
     return d->m_viewport.geoCoordinates( x, y, lon, lat, unit );
 }
 
 void MarbleMapPrivate::setDocument( const QString& key )
 {
     if ( !m_model->mapTheme() ) {
         // Happens if no valid map theme is set or at application startup
         // if a file is passed via command line parameters and the last
         // map theme has not been loaded yet
         /**
          * @todo Do we need to queue the document and process it once a map
          * theme becomes available?
          */
         return;
     }
 
     GeoDataDocument* doc = m_model->fileManager()->at( key );
 
     for ( const GeoSceneLayer *layer: m_model->mapTheme()->map()->layers() ) {
         if ( layer->backend() != dgml::dgmlValue_geodata
              && layer->backend() != dgml::dgmlValue_vector )
             continue;
 
         // look for documents
         for ( const GeoSceneAbstractDataset *dataset: layer->datasets() ) {
             const GeoSceneGeodata *data = static_cast<const GeoSceneGeodata*>( dataset );
             QString containername = data->sourceFile();
             QString colorize = data->colorize();
             if( key == containername ) {
                 if (colorize == QLatin1String("land")) {
                     m_textureLayer.addLandDocument( doc );
                 }
                 if (colorize == QLatin1String("sea")) {
                     m_textureLayer.addSeaDocument( doc );
                 }
 
                 // set visibility according to theme property
                 if( !data->property().isEmpty() ) {
                     bool value;
                     m_model->mapTheme()->settings()->propertyValue( data->property(), value );
                     doc->setVisible( value );
                     m_model->treeModel()->updateFeature( doc );
                 }
             }
         }
     }
 }
 
 void MarbleMapPrivate::updateTileLevel()
 {
     auto const tileZoomLevel = q->tileZoomLevel();
     m_geometryLayer.setTileLevel(tileZoomLevel);
     m_placemarkLayer.setTileLevel(tileZoomLevel);
     emit q->tileLevelChanged(tileZoomLevel);
 }
 
 // Used to be paintEvent()
 void MarbleMap::paint( GeoPainter &painter, const QRect &dirtyRect )
 {
     Q_UNUSED( dirtyRect );
 
     if (d->m_showDebugPolygons ) {
         if (viewContext() == Animation) {
             painter.setDebugPolygonsLevel(1);
         }
         else {
             painter.setDebugPolygonsLevel(2);
         }
     }
     painter.setDebugBatchRender(d->m_showDebugBatchRender);
 
     if ( !d->m_model->mapTheme() ) {
         mDebug() << "No theme yet!";
         d->m_marbleSplashLayer.render( &painter, &d->m_viewport );
         return;
     }
 
     QElapsedTimer t;
     t.start();
 
     RenderStatus const oldRenderStatus = d->m_renderState.status();
     d->m_layerManager.renderLayers( &painter, &d->m_viewport );
     d->m_renderState = d->m_layerManager.renderState();
     bool const parsing = d->m_model->fileManager()->pendingFiles() > 0;
     d->m_renderState.addChild(RenderState(QStringLiteral("Files"), parsing ? WaitingForData : Complete));
     RenderStatus const newRenderStatus = d->m_renderState.status();
     if ( oldRenderStatus != newRenderStatus ) {
         emit renderStatusChanged( newRenderStatus );
     }
     emit renderStateChanged( d->m_renderState );
 
     if ( d->m_showFrameRate ) {
         FpsLayer fpsPainter( &t );
         fpsPainter.paint( &painter );
     }
 
     const qreal fps = 1000.0 / (qreal)( t.elapsed() );
     emit framesPerSecond( fps );
 }
 
 void MarbleMap::customPaint( GeoPainter *painter )
 {
     Q_UNUSED( painter );
 }
 
 QString MarbleMap::mapThemeId() const
 {
     return d->m_model->mapThemeId();
 }
 
 void MarbleMap::setMapThemeId( const QString& mapThemeId )
 {
     d->m_model->setMapThemeId( mapThemeId );
 }
 
 void MarbleMapPrivate::updateMapTheme()
 {
     m_layerManager.removeLayer( &m_textureLayer );
     // FIXME Find a better way to do this reset. Maybe connect to themeChanged SIGNAL?
     m_vectorTileLayer.reset();
     m_layerManager.removeLayer( &m_vectorTileLayer );
     m_layerManager.removeLayer( &m_groundLayer );
 
     QObject::connect( m_model->mapTheme()->settings(), SIGNAL(valueChanged(QString,bool)),
                       q, SLOT(updateProperty(QString,bool)) );
     QObject::connect( m_model->mapTheme()->settings(), SIGNAL(valueChanged(QString,bool)),
                       m_model, SLOT(updateProperty(QString,bool)) );
 
     q->setPropertyValue(QStringLiteral("clouds_data"), m_viewParams.showClouds());
 
     QColor backgroundColor = m_styleBuilder.effectColor(m_model->mapTheme()->map()->backgroundColor());
     m_groundLayer.setColor(backgroundColor);
 
     // Check whether there is a texture layer and vectortile layer available:
     if ( m_model->mapTheme()->map()->hasTextureLayers() ) {
         const GeoSceneSettings *const settings = m_model->mapTheme()->settings();
         const GeoSceneGroup *const textureLayerSettings = settings ? settings->group( "Texture Layers" ) : nullptr;
         const GeoSceneGroup *const vectorTileLayerSettings = settings ? settings->group( "VectorTile Layers" ) : nullptr;
 
         bool textureLayersOk = true;
         bool vectorTileLayersOk = true;
 
         // textures will contain texture layers and
         // vectorTiles vectortile layers
         QVector<const GeoSceneTextureTileDataset *> textures;
         QVector<const GeoSceneVectorTileDataset *> vectorTiles;
 
         for( GeoSceneLayer* layer: m_model->mapTheme()->map()->layers() ){
             if ( layer->backend() == dgml::dgmlValue_texture ){
 
                 for ( const GeoSceneAbstractDataset *pos: layer->datasets() ) {
                     const GeoSceneTextureTileDataset *const texture = dynamic_cast<GeoSceneTextureTileDataset const *>( pos );
                     if ( !texture )
                         continue;
 
                     const QString sourceDir = texture->sourceDir();
                     const QString installMap = texture->installMap();
                     const QString role = layer->role();
 
                     // If the tiles aren't already there, put up a progress dialog
                     // while creating them.
                     if ( !TileLoader::baseTilesAvailable( *texture )
                          && !installMap.isEmpty() )
                     {
                         mDebug() << "Base tiles not available. Creating Tiles ... \n"
                                  << "SourceDir: " << sourceDir << "InstallMap:" << installMap;
 
                         TileCreator *tileCreator = new TileCreator(
                                     sourceDir,
                                     installMap,
                                     (role == QLatin1String("dem")) ? "true" : "false" );
                         tileCreator->setTileFormat( texture->fileFormat().toLower() );
 
                         QPointer<TileCreatorDialog> tileCreatorDlg = new TileCreatorDialog( tileCreator, nullptr );
                         tileCreatorDlg->setSummary( m_model->mapTheme()->head()->name(),
                                                     m_model->mapTheme()->head()->description() );
                         tileCreatorDlg->exec();
                         if ( TileLoader::baseTilesAvailable( *texture ) ) {
                             mDebug() << "Base tiles for" << sourceDir << "successfully created.";
                         } else {
                             qWarning() << "Some or all base tiles for" << sourceDir << "could not be created.";
                         }
 
                         delete tileCreatorDlg;
                     }
 
                     if ( TileLoader::baseTilesAvailable( *texture ) ) {
                         textures.append( texture );
                     } else {
                         qWarning() << "Base tiles for" << sourceDir << "not available. Skipping all texture layers.";
                         textureLayersOk = false;
                     }
                 }
             }
             else if ( layer->backend() == dgml::dgmlValue_vectortile ){
 
                 for ( const GeoSceneAbstractDataset *pos: layer->datasets() ) {
                     const GeoSceneVectorTileDataset *const vectorTile = dynamic_cast<GeoSceneVectorTileDataset const *>( pos );
                     if ( !vectorTile )
                         continue;
 
                     const QString sourceDir = vectorTile->sourceDir();
                     const QString installMap = vectorTile->installMap();
                     const QString role = layer->role();
 
                     // If the tiles aren't already there, put up a progress dialog
                     // while creating them.
                     if ( !TileLoader::baseTilesAvailable( *vectorTile )
                          && !installMap.isEmpty() )
                     {
                         mDebug() << "Base tiles not available. Creating Tiles ... \n"
                                  << "SourceDir: " << sourceDir << "InstallMap:" << installMap;
 
                         TileCreator *tileCreator = new TileCreator(
                                     sourceDir,
                                     installMap,
                                     (role == QLatin1String("dem")) ? "true" : "false" );
                         tileCreator->setTileFormat( vectorTile->fileFormat().toLower() );
 
                         QPointer<TileCreatorDialog> tileCreatorDlg = new TileCreatorDialog( tileCreator, nullptr );
                         tileCreatorDlg->setSummary( m_model->mapTheme()->head()->name(),
                                                     m_model->mapTheme()->head()->description() );
                         tileCreatorDlg->exec();
                         if ( TileLoader::baseTilesAvailable( *vectorTile ) ) {
                             qDebug() << "Base tiles for" << sourceDir << "successfully created.";
                         } else {
                             qDebug() << "Some or all base tiles for" << sourceDir << "could not be created.";
                         }
 
                         delete tileCreatorDlg;
                     }
 
                     if ( TileLoader::baseTilesAvailable( *vectorTile ) ) {
                         vectorTiles.append( vectorTile );
                     } else {
                         qWarning() << "Base tiles for" << sourceDir << "not available. Skipping all texture layers.";
                         vectorTileLayersOk = false;
                     }
                 }
             }
         }
 
         QString seafile, landfile;
         if( !m_model->mapTheme()->map()->filters().isEmpty() ) {
             const GeoSceneFilter *filter= m_model->mapTheme()->map()->filters().first();
 
             if (filter->type() == QLatin1String("colorize")) {
                 //no need to look up with MarbleDirs twice so they are left null for now
                 QList<const GeoScenePalette*> palette = filter->palette();
                 for (const GeoScenePalette *curPalette: palette ) {
 
                     if (curPalette->type() == QLatin1String("sea")) {
                         seafile = MarbleDirs::path( curPalette->file() );
                     } else if (curPalette->type() == QLatin1String("land")) {
                         landfile = MarbleDirs::path( curPalette->file() );
                     }
                 }
                 //look up locations if they are empty
                 if( seafile.isEmpty() )
                     seafile = MarbleDirs::path(QStringLiteral("seacolors.leg"));
                 if( landfile.isEmpty() )
                     landfile = MarbleDirs::path(QStringLiteral("landcolors.leg"));
             }
         }
 
         m_textureLayer.setMapTheme( textures, textureLayerSettings, seafile, landfile );
         m_textureLayer.setProjection( m_viewport.projection() );
         m_textureLayer.setShowRelief( q->showRelief() );
 
         m_vectorTileLayer.setMapTheme( vectorTiles, vectorTileLayerSettings );
 
         if (m_textureLayer.layerCount() == 0) {
             m_layerManager.addLayer( &m_groundLayer );
         }
 
         if ( textureLayersOk )
             m_layerManager.addLayer( &m_textureLayer );
         if ( vectorTileLayersOk && !vectorTiles.isEmpty() )
             m_layerManager.addLayer( &m_vectorTileLayer );
     }
     else {
         m_layerManager.addLayer( &m_groundLayer );
         m_textureLayer.setMapTheme( QVector<const GeoSceneTextureTileDataset *>(), nullptr, "", "" );
         m_vectorTileLayer.setMapTheme( QVector<const GeoSceneVectorTileDataset *>(), nullptr );
     }
 
     // earth
     m_placemarkLayer.setShowPlaces( q->showPlaces() );
 
     m_placemarkLayer.setShowCities( q->showCities() );
     m_placemarkLayer.setShowTerrain( q->showTerrain() );
     m_placemarkLayer.setShowOtherPlaces( q->showOtherPlaces() );
     m_placemarkLayer.setShowLandingSites(q->propertyValue(QStringLiteral("landingsites")));
     m_placemarkLayer.setShowCraters(q->propertyValue(QStringLiteral("craters")));
     m_placemarkLayer.setShowMaria(q->propertyValue(QStringLiteral("maria")));
 
     m_styleBuilder.setDefaultLabelColor(m_model->mapTheme()->map()->labelColor());
     m_placemarkLayer.requestStyleReset();
 
     for (RenderPlugin *renderPlugin: m_renderPlugins) {
         bool propertyAvailable = false;
         m_model->mapTheme()->settings()->propertyAvailable( renderPlugin->nameId(), propertyAvailable );
         bool propertyValue = false;
         m_model->mapTheme()->settings()->propertyValue( renderPlugin->nameId(), propertyValue );
 
         if ( propertyAvailable ) {
             renderPlugin->setVisible( propertyValue );
         }
     }
 
     emit q->themeChanged( m_model->mapTheme()->head()->mapThemeId() );
 }
 
 void MarbleMap::setPropertyValue( const QString& name, bool value )
 {
     mDebug() << "In MarbleMap the property " << name << "was set to " << value;
     if ( d->m_model->mapTheme() ) {
         d->m_model->mapTheme()->settings()->setPropertyValue( name, value );
         d->m_textureLayer.setNeedsUpdate();
         emit propertyValueChanged(name, value);
     }
     else {
         mDebug() << "WARNING: Failed to access a map theme! Property: " << name;
     }
     if (d->m_textureLayer.layerCount() == 0) {
         d->m_layerManager.addLayer( &d->m_groundLayer );
     }
     else {
         d->m_layerManager.removeLayer( &d->m_groundLayer );
     }
 }
 
 void MarbleMap::setShowOverviewMap( bool visible )
 {
     setPropertyValue(QStringLiteral("overviewmap"), visible);
 }
 
 void MarbleMap::setShowScaleBar( bool visible )
 {
     setPropertyValue(QStringLiteral("scalebar"), visible);
 }
 
 void MarbleMap::setShowCompass( bool visible )
 {
     setPropertyValue(QStringLiteral("compass"), visible);
 }
 
 void MarbleMap::setShowAtmosphere( bool visible )
 {
     for ( RenderPlugin *plugin: renderPlugins() ) {
         if (plugin->nameId() == QLatin1String("atmosphere")) {
             plugin->setVisible( visible );
         }
     }
 
     d->m_viewParams.setShowAtmosphere( visible );
 }
 
 void MarbleMap::setShowCrosshairs( bool visible )
 {
     QList<RenderPlugin *> pluginList = renderPlugins();
     QList<RenderPlugin *>::const_iterator i = pluginList.constBegin();
     QList<RenderPlugin *>::const_iterator const end = pluginList.constEnd();
     for (; i != end; ++i ) {
         if ((*i)->nameId() == QLatin1String("crosshairs")) {
             (*i)->setVisible( visible );
         }
     }
 }
 
 void MarbleMap::setShowClouds( bool visible )
 {
     d->m_viewParams.setShowClouds( visible );
 
     setPropertyValue(QStringLiteral("clouds_data"), visible);
 }
 
 void MarbleMap::setShowSunShading( bool visible )
 {
     d->m_textureLayer.setShowSunShading( visible );
 }
 
 void MarbleMap::setShowCityLights( bool visible )
 {
     d->m_textureLayer.setShowCityLights( visible );
     setPropertyValue(QStringLiteral("citylights"), visible);
 }
 
 void MarbleMap::setLockToSubSolarPoint( bool visible )
 {
     disconnect( d->m_model->sunLocator(), SIGNAL(positionChanged(qreal,qreal)),
                 this,                     SLOT(centerOn(qreal,qreal)) );
 
     if( isLockedToSubSolarPoint() != visible ) {
         d->m_isLockedToSubSolarPoint = visible;
     }
 
     if ( isLockedToSubSolarPoint() ) {
         connect( d->m_model->sunLocator(), SIGNAL(positionChanged(qreal,qreal)),
                  this,                     SLOT(centerOn(qreal,qreal)) );
 
         centerOn( d->m_model->sunLocator()->getLon(), d->m_model->sunLocator()->getLat() );
     } else if ( visible ) {
         mDebug() << "Ignoring centering on sun, since the sun plugin is not loaded.";
     }
 }
 
 void MarbleMap::setSubSolarPointIconVisible( bool visible )
 {
     if ( isSubSolarPointIconVisible() != visible ) {
         d->m_isSubSolarPointIconVisible = visible;
     }
 }
 
 void MarbleMap::setShowTileId( bool visible )
 {
     d->m_textureLayer.setShowTileId( visible );
 }
 
 void MarbleMap::setShowGrid( bool visible )
 {
     setPropertyValue(QStringLiteral("coordinate-grid"), visible);
 }
 
 void MarbleMap::setShowPlaces( bool visible )
 {
     setPropertyValue(QStringLiteral("places"), visible);
 }
 
 void MarbleMap::setShowCities( bool visible )
 {
     setPropertyValue(QStringLiteral("cities"), visible);
 }
 
 void MarbleMap::setShowTerrain( bool visible )
 {
     setPropertyValue(QStringLiteral("terrain"), visible);
 }
 
 void MarbleMap::setShowOtherPlaces( bool visible )
 {
     setPropertyValue(QStringLiteral("otherplaces"), visible);
 }
 
 void MarbleMap::setShowRelief( bool visible )
 {
     setPropertyValue(QStringLiteral("relief"), visible);
 }
 
 void MarbleMap::setShowIceLayer( bool visible )
 {
     setPropertyValue(QStringLiteral("ice"), visible);
 }
 
 void MarbleMap::setShowBorders( bool visible )
 {
     setPropertyValue(QStringLiteral("borders"), visible);
 }
 
 void MarbleMap::setShowRivers( bool visible )
 {
     setPropertyValue(QStringLiteral("rivers"), visible);
 }
 
 void MarbleMap::setShowLakes( bool visible )
 {
     setPropertyValue(QStringLiteral("lakes"), visible);
 }
 
 void MarbleMap::setShowFrameRate( bool visible )
 {
     d->m_showFrameRate = visible;
 }
 
 void MarbleMap::setShowRuntimeTrace( bool visible )
 {
     if (visible != d->m_layerManager.showRuntimeTrace()) {
         d->m_layerManager.setShowRuntimeTrace(visible);
         emit repaintNeeded();
     }
 }
 
 bool MarbleMap::showRuntimeTrace() const
 {
     return d->m_layerManager.showRuntimeTrace();
 }
 
 void MarbleMap::setShowDebugPolygons( bool visible)
 {
     if (visible != d->m_showDebugPolygons) {
         d->m_showDebugPolygons = visible;
         emit repaintNeeded();
     }
 }
 
 bool MarbleMap::showDebugPolygons() const
 {
     return d->m_showDebugPolygons;
 }
 
 void MarbleMap::setShowDebugBatchRender( bool visible)
 {
     qDebug() << visible;
     if (visible != d->m_showDebugBatchRender) {
         d->m_showDebugBatchRender = visible;
         emit repaintNeeded();
     }
 }
 
 bool MarbleMap::showDebugBatchRender() const
 {
     return d->m_showDebugBatchRender;
 }
 
 void MarbleMap::setShowDebugPlacemarks( bool visible)
 {
     if (visible != d->m_placemarkLayer.isDebugModeEnabled()) {
         d->m_placemarkLayer.setDebugModeEnabled(visible);
         emit repaintNeeded();
     }
 }
 
 bool MarbleMap::showDebugPlacemarks() const
 {
     return d->m_placemarkLayer.isDebugModeEnabled();
 }
 
 void MarbleMap::setLevelTagDebugModeEnabled(bool visible)
 {
     if (visible != d->m_geometryLayer.levelTagDebugModeEnabled()) {
         d->m_geometryLayer.setLevelTagDebugModeEnabled(visible);
         d->m_placemarkLayer.setLevelTagDebugModeEnabled(visible);
         emit repaintNeeded();
     }
 }
 
 bool MarbleMap::levelTagDebugModeEnabled() const
 {
     return d->m_geometryLayer.levelTagDebugModeEnabled() &&
            d->m_placemarkLayer.levelTagDebugModeEnabled();
 }
 
 void MarbleMap::setDebugLevelTag(int level)
 {
     d->m_geometryLayer.setDebugLevelTag(level);
     d->m_placemarkLayer.setDebugLevelTag(level);
 }
 
 int MarbleMap::debugLevelTag() const
 {
     return d->m_geometryLayer.debugLevelTag();
 }
 
 void MarbleMap::setShowBackground( bool visible )
 {
     d->m_layerManager.setShowBackground( visible );
 }
 
 void MarbleMap::setVisibleRelationTypes(GeoDataRelation::RelationTypes relationTypes)
 {
     if (d->m_visibleRelationTypes != relationTypes) {
         d->m_visibleRelationTypes = relationTypes;
         d->m_geometryLayer.setVisibleRelationTypes(relationTypes);
         emit visibleRelationTypesChanged(d->m_visibleRelationTypes);
     }
 }
 
 void MarbleMap::notifyMouseClick( int x, int y )
 {
     qreal  lon   = 0;
     qreal  lat   = 0;
 
     const bool valid = geoCoordinates( x, y, lon, lat, GeoDataCoordinates::Radian );
 
     if ( valid ) {
         emit mouseClickGeoPosition( lon, lat, GeoDataCoordinates::Radian );
     }
 }
 
 void MarbleMap::clearVolatileTileCache()
 {
     d->m_vectorTileLayer.reset();
     d->m_textureLayer.reset();
     mDebug() << "Cleared Volatile Cache!";
 }
 
 void MarbleMap::setVolatileTileCacheLimit( quint64 kilobytes )
 {
     mDebug() << "kiloBytes" << kilobytes;
     d->m_textureLayer.setVolatileCacheLimit( kilobytes );
 }
 
 AngleUnit MarbleMap::defaultAngleUnit() const
 {
     if ( GeoDataCoordinates::defaultNotation() == GeoDataCoordinates::Decimal ) {
         return DecimalDegree;
     } else if ( GeoDataCoordinates::defaultNotation() == GeoDataCoordinates::UTM ) {
         return UTM;
     }
 
     return DMSDegree;
 }
 
 void MarbleMap::setDefaultAngleUnit( AngleUnit angleUnit )
 {
     if ( angleUnit == DecimalDegree ) {
         GeoDataCoordinates::setDefaultNotation( GeoDataCoordinates::Decimal );
         return;
     } else if ( angleUnit == UTM ) {
         GeoDataCoordinates::setDefaultNotation( GeoDataCoordinates::UTM );
         return;
     }
 
     GeoDataCoordinates::setDefaultNotation( GeoDataCoordinates::DMS );
 }
 
 QFont MarbleMap::defaultFont() const
 {
     return d->m_styleBuilder.defaultFont();
 }
 
 void MarbleMap::setDefaultFont( const QFont& font )
 {
     d->m_styleBuilder.setDefaultFont(font);
     d->m_placemarkLayer.requestStyleReset();
 }
 
 QList<RenderPlugin *> MarbleMap::renderPlugins() const
 {
     return d->m_renderPlugins;
 }
 
 QList<AbstractFloatItem *> MarbleMap::floatItems() const
 {
     return d->m_floatItemsLayer.floatItems();
 }
 
 AbstractFloatItem * MarbleMap::floatItem( const QString &nameId ) const
 {
     for ( AbstractFloatItem * floatItem: floatItems() ) {
         if ( floatItem && floatItem->nameId() == nameId ) {
             return floatItem;
         }
     }
 
     return nullptr; // No item found
 }
 
 QList<AbstractDataPlugin *> MarbleMap::dataPlugins()  const
 {
     return d->m_layerManager.dataPlugins();
 }
 
 QList<AbstractDataPluginItem *> MarbleMap::whichItemAt( const QPoint& curpos ) const
 {
     return d->m_layerManager.whichItemAt( curpos );
 }
 
 void MarbleMap::addLayer( LayerInterface *layer )
 {
     d->m_layerManager.addLayer(layer);
 }
 
 void MarbleMap::removeLayer( LayerInterface *layer )
 {
     d->m_layerManager.removeLayer(layer);
 }
 
 RenderStatus MarbleMap::renderStatus() const
 {
     return d->m_layerManager.renderState().status();
 }
 
 RenderState MarbleMap::renderState() const
 {
     return d->m_layerManager.renderState();
 }
 
 QString MarbleMap::addTextureLayer(GeoSceneTextureTileDataset *texture)
 {
     return textureLayer()->addTextureLayer(texture);
 }
 
 void  MarbleMap::removeTextureLayer(const QString &key)
 {
     textureLayer()->removeTextureLayer(key);
 }
 
 // this method will only temporarily "pollute" the MarbleModel class
 TextureLayer *MarbleMap::textureLayer() const
 {
     return &d->m_textureLayer;
 }
 
 VectorTileLayer *MarbleMap::vectorTileLayer() const
 {
     return &d->m_vectorTileLayer;
 }
 
 const StyleBuilder* MarbleMap::styleBuilder() const
 {
     return &d->m_styleBuilder;
 }
 
 qreal MarbleMap::heading() const
 {
     return d->m_viewport.heading() * RAD2DEG;
 }
 
 void MarbleMap::setHeading( qreal heading )
 {
     d->m_viewport.setHeading( heading * DEG2RAD );
     d->m_textureLayer.setNeedsUpdate();
 
     emit visibleLatLonAltBoxChanged( d->m_viewport.viewLatLonAltBox() );
 }
 
 }
 
 #include "moc_MarbleMap.cpp"