diff --git a/src/apps/marble-ui/ControlView.cpp b/src/apps/marble-ui/ControlView.cpp
index 80cec7d91..a4347be4a 100644
--- a/src/apps/marble-ui/ControlView.cpp
+++ b/src/apps/marble-ui/ControlView.cpp
@@ -1,982 +1,982 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2006-2007 Torsten Rahn <tackat@kde.org>
 // Copyright 2007      Inge Wallin  <ingwa@kde.org>
 //
 
 
 #include "ControlView.h"
 
 #include <QCloseEvent>
 #include <QLayout>
 #include <QPrintDialog>
 #include <QPrintPreviewDialog>
 #include <QPrinter>
 #include <QPainter>
 #include <QTextDocument>
 #include <QPointer>
 #include <QUrl>
 #include <QDesktopServices>
 #include <QNetworkAccessManager>
 #include <QNetworkReply>
 #include <QNetworkRequest>
 #include <QProcess>
 #include <QTimer>
 #include <QFileInfo>
 #include <QMessageBox>
 #include <QMainWindow>
 #include <QDockWidget>
 #include <QShortcut>
 #include <QToolBar>
 #include <QMimeData>
 #include <QPixmap>
 
 #ifdef MARBLE_DBUS
 #include <QDBusConnection>
 #include "MarbleDBusInterface.h"
 #endif
 
 #include "GeoDataLatLonAltBox.h"
 #include "GeoSceneDocument.h"
 #include "GeoSceneHead.h"
 #include "GeoUriParser.h"
 #include "MarbleWidget.h"
 #include "MarbleDebug.h"
 #include "MarbleDirs.h"
 #include "MarbleModel.h"
 #include "MarbleMap.h"
 #include "MapThemeManager.h"
 #include "PrintOptionsWidget.h"
 #include "ViewportParams.h"
 #include "ViewParams.h"
 #include "routing/Route.h"
 #include "routing/RoutingManager.h"
 #include "routing/RoutingModel.h"
 #include "routing/RouteRequest.h"
 #include "routing/RoutingWidget.h"
 #include "ExternalEditorDialog.h"
 #include "CurrentLocationWidget.h"
 #include "SearchWidget.h"
 #include "TourWidget.h"
 #include "MapViewWidget.h"
 #include "FileViewWidget.h"
 #include "LegendWidget.h"
 #include "BookmarkManager.h"
 #include "cloudsync/CloudSyncManager.h"
 #include "cloudsync/BookmarkSyncManager.h"
 #include "cloudsync/RouteSyncManager.h"
 #include "cloudsync/ConflictDialog.h"
 #include "cloudsync/MergeItem.h"
 #include "RenderPlugin.h"
 
 namespace Marble
 {
 
 ControlView::ControlView( QWidget *parent )
    : QWidget( parent ),
      m_mapThemeManager( new MapThemeManager( this ) ),
      m_searchDock( 0 ),
      m_locationWidget( 0 ),
      m_conflictDialog( 0 ),
      m_togglePanelVisibilityAction( 0 ),
      m_isPanelVisible( true ),
      m_tourWidget( 0 ),
      m_annotationDock( 0 ),
      m_annotationPlugin( 0 )
 {
     setWindowTitle( tr( "Marble - Virtual Globe" ) );
 
     resize( 680, 640 );
 
     m_marbleWidget = new MarbleWidget( this );
     m_marbleWidget->setSizePolicy( QSizePolicy( QSizePolicy::MinimumExpanding,
                                                 QSizePolicy::MinimumExpanding ) );
 #ifdef MARBLE_DBUS
     new MarbleDBusInterface( m_marbleWidget );
     QDBusConnection::sessionBus().registerObject( "/Marble", m_marbleWidget );
     if (!QDBusConnection::sessionBus().registerService( "org.kde.marble" )) {
         QString const urlWithPid = QString("org.kde.marble-%1").arg( QCoreApplication::applicationPid() );
         if ( !QDBusConnection::sessionBus().registerService( urlWithPid ) ) {
             mDebug() << "Failed to register service org.kde.marble and " << urlWithPid << " with the DBus session bus.";
         }
     }
 #endif
 
 
     QVBoxLayout* layout = new QVBoxLayout;
     layout->addWidget( m_marbleWidget );
     layout->setMargin( 0 );
     setLayout( layout );
 
     m_cloudSyncManager = new CloudSyncManager( this );
     m_cloudSyncManager->routeSyncManager()->setRoutingManager( m_marbleWidget->model()->routingManager() );
     BookmarkSyncManager* bookmarkSyncManager = m_cloudSyncManager->bookmarkSyncManager();
     bookmarkSyncManager->setBookmarkManager( m_marbleWidget->model()->bookmarkManager() );
     m_conflictDialog = new ConflictDialog( m_marbleWidget );
     connect( bookmarkSyncManager, SIGNAL(mergeConflict(MergeItem*)), this, SLOT(showConflictDialog(MergeItem*)) );
     connect( bookmarkSyncManager, SIGNAL(syncComplete()), m_conflictDialog, SLOT(stopAutoResolve()) );
     connect( m_conflictDialog, SIGNAL(resolveConflict(MergeItem*)), bookmarkSyncManager, SLOT(resolveConflict(MergeItem*)) );
 
     setAcceptDrops(true);
 }
 
 ControlView::~ControlView()
 {
     // nothing to do
 }
 
 QString ControlView::applicationVersion()
 {
-    return "2.1.20 (2.2 development version)";
+    return "2.2.0 (stable release)";
 }
 
 MapThemeManager *ControlView::mapThemeManager()
 {
     return m_mapThemeManager;
 }
 
 void ControlView::zoomIn()
 {
     m_marbleWidget->zoomIn();
 }
 
 void ControlView::zoomOut()
 {
     m_marbleWidget->zoomOut();
 }
 
 void ControlView::moveLeft()
 {
     m_marbleWidget->moveLeft();
 }
 
 void ControlView::moveRight()
 {
     m_marbleWidget->moveRight();
 }
 
 void ControlView::moveUp()
 {
     m_marbleWidget->moveUp();
 }
 
 void ControlView::moveDown()
 {
     m_marbleWidget->moveDown();
 }
 
 QString ControlView::defaultMapThemeId() const
 {
     QStringList fallBackThemes;
       fallBackThemes << "earth/srtm/srtm.dgml";
       fallBackThemes << "earth/bluemarble/bluemarble.dgml";
       fallBackThemes << "earth/openstreetmap/openstreetmap.dgml";
 
     const QStringList installedThemes = m_mapThemeManager->mapThemeIds();
 
     for(const QString &fallback: fallBackThemes) {
         if (installedThemes.contains(fallback)) {
             return fallback;
         }
     }
 
     if (installedThemes.size()) {
         return installedThemes.first();
     }
 
     return QString();
 }
 
 void ControlView::printMapScreenShot( const QPointer<QPrintDialog>& printDialog)
 {
 #ifndef QT_NO_PRINTER
         PrintOptionsWidget* printOptions = new PrintOptionsWidget( this );
         bool const mapCoversViewport = m_marbleWidget->viewport()->mapCoversViewport();
         printOptions->setBackgroundControlsEnabled( !mapCoversViewport );
         bool hasLegend = m_marbleWidget->model()->legend() != 0;
         printOptions->setLegendControlsEnabled( hasLegend );
         bool hasRoute = marbleWidget()->model()->routingManager()->routingModel()->rowCount() > 0;
         printOptions->setPrintRouteSummary( hasRoute );
         printOptions->setPrintDrivingInstructions( hasRoute );
         printOptions->setPrintDrivingInstructionsAdvice( hasRoute );
         printOptions->setRouteControlsEnabled( hasRoute );
         printDialog->setOptionTabs( QList<QWidget*>() << printOptions );
 
         if ( printDialog->exec() == QDialog::Accepted ) {
             QTextDocument document;
             QString text = "<html><head><title>Marble Printout</title></head><body>";
             QPalette const originalPalette = m_marbleWidget->palette();
             bool const wasBackgroundVisible = m_marbleWidget->showBackground();
             bool const hideBackground = !mapCoversViewport && !printOptions->printBackground();
             if ( hideBackground ) {
                 // Temporarily remove the black background and layers painting on it
                 m_marbleWidget->setShowBackground( false );
                 m_marbleWidget->setPalette( QPalette ( Qt::white ) );
                 m_marbleWidget->update();
             }
 
             if ( printOptions->printMap() ) {
                 printMap( document, text, printDialog->printer() );
             }
 
             if ( printOptions->printLegend() ) {
                 printLegend( document, text );
             }
 
             if ( printOptions->printRouteSummary() ) {
                 printRouteSummary( document, text );
             }
 
             if ( printOptions->printDrivingInstructions() ) {
                 printDrivingInstructions( document, text );
             }
 
             if ( printOptions->printDrivingInstructionsAdvice() ) {
                 printDrivingInstructionsAdvice( document, text );
             }
 
             text += QLatin1String("</body></html>");
             document.setHtml( text );
             document.print( printDialog->printer() );
 
             if ( hideBackground ) {
                 m_marbleWidget->setShowBackground( wasBackgroundVisible );
                 m_marbleWidget->setPalette( originalPalette );
                 m_marbleWidget->update();
             }
     }
 #endif
 }
 
 bool ControlView::openGeoUri( const QString& geoUriString )
 {
     GeoUriParser uriParser( geoUriString );
     const bool success = uriParser.parse();
     if ( success ) {
         if ( uriParser.planet().id() != marbleModel()->planet()->id() ) {
             MapThemeManager *manager = mapThemeManager();
             for( const QString& planetName: manager->mapThemeIds()) {
                 if ( planetName.startsWith(uriParser.planet().id(), Qt::CaseInsensitive)) {
                     m_marbleWidget->setMapThemeId(planetName);
                     break;
                 }
             }
         }
         m_marbleWidget->centerOn( uriParser.coordinates() );
         if ( uriParser.coordinates().altitude() > 0.0 )
         {
             m_marbleWidget->setDistance( uriParser.coordinates().altitude() * METER2KM );
         }
     }
     return success;
 }
 
 QActionGroup *ControlView::createViewSizeActionGroup( QObject* parent )
 {
     QActionGroup* actionGroup = new QActionGroup( parent );
 
     QAction *defaultAction = new QAction( tr( "Default (Resizable)" ), parent );
     defaultAction->setCheckable( true );
     defaultAction->setChecked( true );
     actionGroup->addAction(defaultAction);
 
     QAction *separator = new QAction( parent );
     separator->setSeparator( true );
     actionGroup->addAction(separator);
 
     addViewSizeAction( actionGroup, tr("NTSC (%1x%2)"), 720, 486 );
     addViewSizeAction( actionGroup, tr("PAL (%1x%2)"), 720, 576 );
     addViewSizeAction( actionGroup, tr("NTSC 16:9 (%1x%2)"), 864, 486 );
     addViewSizeAction( actionGroup, tr("PAL 16:9 (%1x%2)"), 1024, 576 );
     // xgettext:no-c-format
     addViewSizeAction( actionGroup, tr("DVD (%1x%2p)"), 852, 480 );
     // xgettext:no-c-format
     addViewSizeAction( actionGroup, tr("HD (%1x%2p)"), 1280, 720 );
     // xgettext:no-c-format
     addViewSizeAction( actionGroup, tr("Full HD (%1x%2p)"), 1920, 1080 );
     addViewSizeAction( actionGroup, tr("Digital Cinema (%1x%2)"), 2048, 1536 );
     /** FIXME: Needs testing, worked with errors.
     addViewSizeAction(actionGroup, "4K UHD (%1x%2)", 3840, 2160);
     addViewSizeAction(actionGroup, "4K (%1x%2)", 4096, 3072);
     */
 
     return actionGroup;
 }
 
 void ControlView::printPixmap( QPrinter * printer, const QPixmap& pixmap  )
 {
 #ifndef QT_NO_PRINTER
     QSize printSize = pixmap.size();
     QRect mapPageRect = printer->pageRect();
     printSize.scale( printer->pageRect().size(), Qt::KeepAspectRatio );
     QPoint printTopLeft( ( mapPageRect.width() - printSize.width() ) / 2 ,
                          ( mapPageRect.height() - printSize.height() ) / 2 );
     QRect mapPrintRect( printTopLeft, printSize );
 
     QPainter painter;
     if (!painter.begin(printer))
         return;
     painter.drawPixmap( mapPrintRect, pixmap, pixmap.rect() );
     painter.end();
 #endif
 }
 
 // QPointer is used because of issues described in http://www.kdedevelopers.org/node/3919
 void ControlView::printPreview()
 {
 #ifndef QT_NO_PRINTER
     QPrinter printer( QPrinter::HighResolution );
 
     QPointer<QPrintPreviewDialog> preview = new QPrintPreviewDialog( &printer, this );
     preview->setWindowFlags ( Qt::Window );
     preview->resize(640, 480);
     connect( preview, SIGNAL(paintRequested(QPrinter*)), SLOT(paintPrintPreview(QPrinter*)) );
     preview->exec();
     delete preview;
 #endif
 }
 
 void ControlView::paintPrintPreview( QPrinter * printer )
 {
 #ifndef QT_NO_PRINTER
     QPixmap mapPixmap = mapScreenShot();
     printPixmap( printer, mapPixmap );
 #endif
 }
 
 void ControlView::printMap( QTextDocument &document, QString &text, QPrinter *printer )
 {
 #ifndef QT_NO_PRINTER
     QPixmap image = mapScreenShot();
 
     if ( m_marbleWidget->viewport()->mapCoversViewport() ) {
         // Paint a black frame. Looks better.
         QPainter painter(&image);
         painter.setPen( Qt::black );
         painter.drawRect( 0, 0, image.width() - 2, image.height() - 2 );
     }
 
     QString uri = "marble://screenshot.png";
     document.addResource( QTextDocument::ImageResource, QUrl( uri ), QVariant( image) );
     QString img = "<img src=\"%1\" width=\"%2\" align=\"center\">";
     int width = qRound( printer->pageRect( QPrinter::Point ).width() );
     text += img.arg( uri ).arg( width );
 #endif
 }
 
 void ControlView::printLegend( QTextDocument &document, QString &text )
 {
 #ifndef QT_NO_PRINTER
     QTextDocument *legend = m_marbleWidget->model()->legend();
     if ( legend ) {
         legend->adjustSize();
         QSize size = legend->size().toSize();
         QSize imageSize = size + QSize( 4, 4 );
         QImage image( imageSize, QImage::Format_ARGB32);
         QPainter painter( &image );
         painter.setRenderHint( QPainter::Antialiasing, true );
         painter.drawRoundedRect( QRect( QPoint( 0, 0 ), size ), 5, 5 );
         legend->drawContents( &painter );
         document.addResource( QTextDocument::ImageResource, QUrl( "marble://legend.png" ), QVariant(image) );
         QString img = "<p><img src=\"%1\" align=\"center\"></p>";
         text += img.arg( "marble://legend.png" );
     }
 #endif
 }
 
 void ControlView::printRouteSummary( QTextDocument &document, QString &text)
 {
 #ifndef QT_NO_PRINTER
     RoutingModel* routingModel = m_marbleWidget->model()->routingManager()->routingModel();
 
     if ( !routingModel ) {
         return;
     }
 
     RouteRequest* routeRequest = m_marbleWidget->model()->routingManager()->routeRequest();
     if ( routeRequest ) {
         QString summary = "<h3>Route to %1: %2 %3</h3>";
         QString destination;
         if ( routeRequest->size() ) {
             destination = routeRequest->name( routeRequest->size()-1 );
         }
 
         QString label = "<p>%1 %2</p>";
         qreal distance = routingModel->route().distance();
         QString unit = distance > 1000 ? "km" : "m";
         int precision = distance > 1000 ? 1 : 0;
         if ( distance > 1000 ) {
             distance /= 1000;
         }
         summary = summary.arg(destination).arg( distance, 0, 'f', precision ).arg( unit );
         text += summary;
 
         text += QLatin1String("<table cellpadding=\"2\">");
         QString pixmapTemplate = "marble://viaPoint-%1.png";
         for ( int i=0; i<routeRequest->size(); ++i ) {
             text += QLatin1String("<tr><td>");
             QPixmap pixmap = routeRequest->pixmap(i);
             QString pixmapResource = pixmapTemplate.arg( i );
             document.addResource(QTextDocument::ImageResource,
                                           QUrl( pixmapResource ), QVariant( pixmap ) );
             QString myimg = "<img src=\"%1\">";
             text += myimg.arg(pixmapResource) +
                     QLatin1String("</td><td>");
                     routeRequest->name(i) +
                     QLatin1String("</td></tr>");
         }
         text += QLatin1String("</table>");
     }
 #endif
 }
 
 void ControlView::printDrivingInstructions( QTextDocument &document, QString &text )
 {
 #ifndef QT_NO_PRINTER
     RoutingModel* routingModel = m_marbleWidget->model()->routingManager()->routingModel();
 
     if (!routingModel) {
         return;
     }
 
     GeoDataLineString total = routingModel->route().path();
 
     text += QLatin1String("<table cellpadding=\"4\">"
             "<tr><th>No.</th><th>Distance</th><th>Instruction</th></tr>");
     for ( int i=0; i<routingModel->rowCount(); ++i ) {
         QModelIndex index = routingModel->index(i, 0);
         GeoDataCoordinates coordinates = index.data( RoutingModel::CoordinateRole ).value<GeoDataCoordinates>();
         GeoDataLineString accumulator;
         for (int k=0; k<total.size(); ++k) {
             accumulator << total.at(k);
 
             if (total.at(k) == coordinates)
                 break;
         }
 
         if ( i%2 == 0 ) {
             text += QLatin1String("<tr bgcolor=\"lightGray\"><td align=\"right\" valign=\"middle\">");
         }
         else {
             text += QLatin1String("<tr><td align=\"right\" valign=\"middle\">");
         }
         text += QString::number(i+1) +
                 QLatin1String("</td><td align=\"right\" valign=\"middle\">");
 
         qreal planetRadius = marbleModel()->planet()->radius();
         text += QString::number(accumulator.length(planetRadius) * METER2KM, 'f', 1) +
                 /** @todo: support localization */
                 QLatin1String(" km</td><td valign=\"middle\">");
 
         QPixmap instructionIcon = index.data( Qt::DecorationRole ).value<QPixmap>();
         if ( !instructionIcon.isNull() ) {
             QString uri = QString("marble://turnIcon%1.png").arg(i);
             document.addResource( QTextDocument::ImageResource, QUrl( uri ), QVariant( instructionIcon ) );
             text += QString("<img src=\"%1\">").arg(uri);
         }
 
         text += routingModel->data( index ).toString() +
                 QLatin1String("</td></tr>");
     }
     text += QLatin1String("</table>");
 #endif
 }
 
 void ControlView::printDrivingInstructionsAdvice( QTextDocument &, QString &text )
 {
 #ifndef QT_NO_PRINTER
     text += QLatin1String("<p>") + tr("The Marble development team wishes you a pleasant and safe journey.") + QLatin1String("</p>") +
             QLatin1String("<p>") + tr("Caution: Driving instructions may be incomplete or inaccurate.") +
             QLatin1Char(' ') + tr("Road construction, weather and other unforeseen variables can result in this suggested route not to be the most expedient or safest route to your destination.") +
             QLatin1Char(' ') + tr("Please use common sense while navigating.") + QLatin1String("</p>");
 #endif
 }
 
 void ControlView::addViewSizeAction( QActionGroup* actionGroup, const QString &nameTemplate, int width, int height )
 {
     QString const name = nameTemplate.arg( width ).arg( height );
     QAction *action = new QAction( name, actionGroup->parent() );
     action->setCheckable( true );
     action->setData( QSize( width, height ) );
     actionGroup->addAction( action );
 }
 
 
 void ControlView::launchExternalMapEditor()
 {
     QString editor = m_externalEditor;
     if ( editor.isEmpty() ) {
         QPointer<ExternalEditorDialog> dialog = new ExternalEditorDialog( this );
         if( dialog->exec() == QDialog::Accepted ) {
             editor = dialog->externalEditor();
             if ( dialog->saveDefault() ) {
                 m_externalEditor = editor;
             }
         } else {
             return;
         }
     }
 
     if (editor == QLatin1String("josm")) {
         // JOSM, the java based editor
         synchronizeWithExternalMapEditor( editor, "--download=%1,%4,%3,%2" );
     }
     else if (editor == QLatin1String("merkaartor")) {
         // Merkaartor, a Qt based editor
         QString argument = "osm://download/load_and_zoom?top=%1&right=%2&bottom=%3&left=%4";
         synchronizeWithExternalMapEditor( editor, argument );
     }
     else {
         // Potlatch, the flash based editor running at the osm main website
         QString url = "http://www.openstreetmap.org/edit?lat=%1&lon=%2&zoom=%3";
         qreal lat = m_marbleWidget->centerLatitude();
         qreal lon = m_marbleWidget->centerLongitude();
         int zoom = m_marbleWidget->tileZoomLevel();
         url = url.arg( lat, 0, 'f', 8 ).arg( lon, 0, 'f', 8 ).arg( zoom );
         QDesktopServices::openUrl( QUrl(url) );
     }
 }
 
 void ControlView::synchronizeWithExternalMapEditor( const QString &application, const QString &argument )
 {
     QTimer watchdog; // terminates network connection after a short timeout
     watchdog.setSingleShot( true );
     QEventLoop localEventLoop;
     connect( &watchdog, SIGNAL(timeout()), &localEventLoop, SLOT(quit()) );
     QNetworkAccessManager manager;
     connect( &manager, SIGNAL(finished(QNetworkReply*)), &localEventLoop, SLOT(quit()) );
 
     // Wait at most two seconds for the local server to respond
     QNetworkReply *reply = manager.get( QNetworkRequest( QUrl( "http://localhost:8111/") ) );
     watchdog.start( 2000 );
     localEventLoop.exec();
 
     GeoDataLatLonAltBox box = m_marbleWidget->viewport()->viewLatLonAltBox();
     qreal north = box.north( GeoDataCoordinates::Degree );
     qreal east  = box.east( GeoDataCoordinates::Degree );
     qreal south = box.south( GeoDataCoordinates::Degree );
     qreal west  = box.west( GeoDataCoordinates::Degree );
 
     if( watchdog.isActive() && reply->bytesAvailable() > 0 ) {
         // The local server is alive. Tell it to download the current region
         watchdog.stop();
         QString serverUrl = "http://localhost:8111/load_and_zoom?top=%1&right=%2&bottom=%3&left=%4";
         serverUrl = serverUrl.arg( north, 0, 'f', 8 ).arg( east, 0, 'f', 8 );
         serverUrl = serverUrl.arg( south, 0, 'f', 8 ).arg( west, 0, 'f', 8 );
         mDebug() << "Connecting to local server URL " << serverUrl;
         manager.get( QNetworkRequest( QUrl( serverUrl ) ) );
 
         // Give it five seconds to process the request
         watchdog.start( 5000 );
         localEventLoop.exec();
     } else {
         // The local server is not alive. Start the application
         QString applicationArgument = argument.arg( south, 0, 'f', 8 ).arg( east, 0, 'f', 8 );
         applicationArgument = applicationArgument.arg( north, 0, 'f', 8 ).arg( west, 0, 'f', 8 );
         mDebug() << "No local server found. Launching " << application << " with argument " << applicationArgument;
         if ( !QProcess::startDetached( application, QStringList() << applicationArgument ) ) {
             QString text = tr( "Unable to start the external editor. Check that %1 is installed or choose a different external editor in the settings dialog." );
             text = text.arg( application );
             QMessageBox::warning( this, tr( "Cannot start external editor" ), text );
         }
     }
 }
 
 void ControlView::setExternalMapEditor( const QString &editor )
 {
     m_externalEditor = editor;
 }
 
 QList<QAction*> ControlView::setupDockWidgets( QMainWindow *mainWindow )
 {
     Q_ASSERT( !m_searchDock && "Please create dock widgets just once" );
 
     mainWindow->setTabPosition( Qt::LeftDockWidgetArea, QTabWidget::North );
     mainWindow->setTabPosition( Qt::RightDockWidgetArea, QTabWidget::North );
 
     QDockWidget* legendDock = new QDockWidget( tr( "Legend" ), this );
     legendDock->setObjectName( "legendDock" );
     legendDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     LegendWidget* legendWidget = new LegendWidget( this );
     legendWidget->setMarbleModel( m_marbleWidget->model() );
     connect( legendWidget, SIGNAL(tourLinkClicked(QString)),
              this, SLOT(handleTourLinkClicked(QString)) );
     connect( legendWidget, SIGNAL(propertyValueChanged(QString,bool)),
              marbleWidget(), SLOT(setPropertyValue(QString,bool)) );
     legendDock->setWidget( legendWidget );
 
     bool const smallScreen = MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen;
     if ( smallScreen ) {
         // Show only the legend as a dock widget on small screen, the others are dialogs
         mainWindow->addDockWidget( Qt::LeftDockWidgetArea, legendDock );
         return QList<QAction*>() << legendDock->toggleViewAction();
     }
 
     QDockWidget *routingDock = new QDockWidget( tr( "Routing" ), mainWindow );
     routingDock->setObjectName( "routingDock" );
     routingDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     RoutingWidget* routingWidget = new RoutingWidget( marbleWidget(), mainWindow );
     routingWidget->setRouteSyncManager( cloudSyncManager()->routeSyncManager() );
     routingDock->setWidget( routingWidget );
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, routingDock );
 
     QDockWidget *locationDock = new QDockWidget( tr( "Location" ), this );
     locationDock->setObjectName( "locationDock" );
     locationDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     m_locationWidget = new CurrentLocationWidget( this );
     m_locationWidget->setMarbleWidget( marbleWidget() );
     locationDock->setWidget( m_locationWidget );
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, locationDock );
 
     m_searchDock = new QDockWidget( tr( "Search" ), this );
     m_searchDock->setObjectName( "searchDock" );
     m_searchDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     SearchWidget* searchWidget = new SearchWidget( this );
     searchWidget->setMarbleWidget( marbleWidget() );
     m_searchDock->setWidget( searchWidget );
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, m_searchDock );
 
     mainWindow->tabifyDockWidget( m_searchDock, routingDock );
     mainWindow->tabifyDockWidget( routingDock, locationDock );
     m_searchDock->raise();
 
     QKeySequence searchSequence( Qt::CTRL + Qt::Key_F );
     searchWidget->setToolTip( tr( "Search for cities, addresses, points of interest and more (%1)" ).arg( searchSequence.toString() ) );
     QShortcut* searchShortcut = new QShortcut( mainWindow );
     connect( searchShortcut, SIGNAL(activated()), this, SLOT(showSearch()) );
 
     QDockWidget *mapViewDock = new QDockWidget( tr( "Map View" ), this );
     mapViewDock->setObjectName( "mapViewDock" );
     mapViewDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     MapViewWidget* mapViewWidget = new MapViewWidget( this );
     mapViewWidget->setMarbleWidget( marbleWidget(), m_mapThemeManager );
     connect( mapViewWidget, SIGNAL(showMapWizard()), this, SIGNAL(showMapWizard()) );
     connect( mapViewWidget, SIGNAL(showUploadDialog()), this, SIGNAL(showUploadDialog()) );
     connect( mapViewWidget, SIGNAL(mapThemeDeleted()), this, SIGNAL(mapThemeDeleted()) );
     mapViewDock->setWidget( mapViewWidget );
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, mapViewDock );
 
     QDockWidget *fileViewDock = new QDockWidget( tr( "Files" ), this );
     fileViewDock->setObjectName( "fileViewDock" );
     fileViewDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     FileViewWidget* fileViewWidget = new FileViewWidget( this );
     fileViewWidget->setMarbleWidget( marbleWidget() );
     fileViewDock->setWidget( fileViewWidget );
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, fileViewDock );
     fileViewDock->hide();
 
     QDockWidget *tourDock = new QDockWidget( tr( "Tour" ), this );
     tourDock->setObjectName( "tourDock" );
     tourDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
     m_tourWidget = new TourWidget( this );
     m_tourWidget->setMarbleWidget( marbleWidget() );
     tourDock->setWidget( m_tourWidget );
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, tourDock );
     tourDock->hide();
 
     mainWindow->addDockWidget( Qt::LeftDockWidgetArea, legendDock );
     mainWindow->tabifyDockWidget( mapViewDock, legendDock );
     mapViewDock->raise();
 
     m_annotationDock = new QDockWidget( QObject::tr( "Edit Maps" ) );
     m_annotationDock->setObjectName( "annotateDock" );
     m_annotationDock->hide();
     m_annotationDock->toggleViewAction()->setVisible( false );
 
     QList<RenderPlugin *> renderPluginList = marbleWidget()->renderPlugins();
     QList<RenderPlugin *>::const_iterator i = renderPluginList.constBegin();
     QList<RenderPlugin *>::const_iterator const end = renderPluginList.constEnd();
 
     for (; i != end; ++i ) {
         if ((*i)->nameId() == QLatin1String("annotation")) {
             m_annotationPlugin = *i;
             QObject::connect(m_annotationPlugin, SIGNAL(enabledChanged(bool)),
                              this, SLOT(updateAnnotationDockVisibility()));
             QObject::connect(m_annotationPlugin, SIGNAL(visibilityChanged(bool,QString)),
                              this, SLOT(updateAnnotationDockVisibility()));
             QObject::connect(m_annotationPlugin, SIGNAL(actionGroupsChanged()),
                              this, SLOT(updateAnnotationDock()));
             updateAnnotationDock();
             updateAnnotationDockVisibility();
             mainWindow->addDockWidget( Qt::LeftDockWidgetArea, m_annotationDock );
         }
     }
 
     mainWindow->tabifyDockWidget( tourDock, m_annotationDock );
     mainWindow->tabifyDockWidget( m_annotationDock, fileViewDock );
 
     QList<QAction*> panelActions;
     panelActions << routingDock->toggleViewAction();
     panelActions << locationDock->toggleViewAction();
     panelActions << m_searchDock->toggleViewAction();
     panelActions << mapViewDock->toggleViewAction();
     panelActions << fileViewDock->toggleViewAction();
     panelActions << m_annotationDock->toggleViewAction();
     panelActions << legendDock->toggleViewAction();
     panelActions << tourDock->toggleViewAction();
 
     // Local list of panel view toggle actions
     m_panelActions << routingDock->toggleViewAction();
     m_panelActions << locationDock->toggleViewAction();
     m_panelActions << m_searchDock->toggleViewAction();
     m_panelActions << mapViewDock->toggleViewAction();
     m_panelActions << fileViewDock->toggleViewAction();
     m_panelActions << m_annotationDock->toggleViewAction();
     m_panelActions << legendDock->toggleViewAction();
     m_panelActions << tourDock->toggleViewAction();
     for( QAction* action: m_panelActions ) {
         m_panelVisibility << action->isVisible();
     }
 
     // Create Settings->Panels Menu
     // Toggle All Panels action
     m_togglePanelVisibilityAction = new QAction( tr("Hide &All Panels"), this);
     m_togglePanelVisibilityAction->setShortcut( Qt::Key_F9 );
     m_togglePanelVisibilityAction->setStatusTip(tr("Show or hide all panels."));
     connect(m_togglePanelVisibilityAction, SIGNAL(triggered()), this, SLOT(togglePanelVisibility()));
 
     // Include a Separator in the List
     QAction *panelSeparatorAct = new QAction( this );
     panelSeparatorAct->setSeparator( true );
 
     // Return a list of panel view actions for Marble Menu including show/hide all
     QList<QAction*> panelMenuActions;
     panelMenuActions << m_togglePanelVisibilityAction;
     panelMenuActions << panelSeparatorAct;
     for( QAction* action: m_panelActions ) {
         panelMenuActions << action;
     }
 
     return panelMenuActions;
 }
 
 CurrentLocationWidget *ControlView::currentLocationWidget()
 {
     return m_locationWidget;
 }
 
 void ControlView::setWorkOffline( bool offline )
 {
     marbleWidget()->model()->setWorkOffline( offline );
     if ( !offline ) {
         marbleWidget()->clearVolatileTileCache();
     }
 }
 
 CloudSyncManager *ControlView::cloudSyncManager()
 {
     return m_cloudSyncManager;
 }
 
 QString ControlView::externalMapEditor() const
 {
     return m_externalEditor;
 }
 
 void ControlView::addGeoDataFile( const QString &filename )
 {
     QFileInfo const file( filename );
     if ( file.exists() ) {
         m_marbleWidget->model()->addGeoDataFile( file.absoluteFilePath() );
     } else {
         qWarning() << "File" << filename << "does not exist, cannot open it.";
     }
 }
 
 void ControlView::showSearch()
 {
     if ( !m_searchDock ) {
         return;
     }
 
     m_searchDock->show();
     m_searchDock->raise();
     m_searchDock->widget()->setFocus();
 }
 
 void ControlView::showConflictDialog( MergeItem *item )
 {
     Q_ASSERT( m_conflictDialog );
     m_conflictDialog->setMergeItem( item );
     m_conflictDialog->open();
 }
 
 void ControlView::updateAnnotationDockVisibility()
 {
     if( m_annotationPlugin != 0 && m_annotationDock != 0 ) {
         if( m_annotationPlugin->visible() && m_annotationPlugin->enabled() ) {
             m_annotationDock->toggleViewAction()->setVisible( true );
         } else {
             m_annotationDock->setVisible( false );
             m_annotationDock->toggleViewAction()->setVisible( false );
         }
     }
 }
 
 void ControlView::updateAnnotationDock()
 {
     const QList<QActionGroup*> *tmp_actionGroups = m_annotationPlugin->actionGroups();
     QWidget *widget = new QWidget( m_annotationDock );
     QVBoxLayout *layout = new QVBoxLayout;
     QToolBar *firstToolbar = new QToolBar( widget );
     QToolBar *secondToolbar = new QToolBar( widget );
     QSpacerItem *spacer = new QSpacerItem( 0, 0, QSizePolicy::Expanding, QSizePolicy::Expanding);
     if( !tmp_actionGroups->isEmpty() ) {
         bool firstToolbarFilled = false;
         for( QAction *action: tmp_actionGroups->first()->actions() ) {
             if (action->objectName() == QLatin1String("toolbarSeparator")) {
                 firstToolbarFilled = true;
             } else {
                 if( !firstToolbarFilled ) {
                     firstToolbar->addAction( action );
                 } else {
                     secondToolbar->addAction( action );
                 }
             }
         }
     }
     layout->addWidget( firstToolbar );
     layout->addWidget( secondToolbar );
     layout->addSpacerItem( spacer );
     widget->setLayout( layout );
     m_annotationDock->setWidget( widget );
 }
 
 void ControlView::togglePanelVisibility()
 {
     Q_ASSERT( m_panelVisibility.size() == m_panelActions.size() );
     if ( m_isPanelVisible ) {
         for( int p=0; p<m_panelActions.size(); ++p ) {
             // Save state of individual dock visibility
             m_panelVisibility[p] = m_panelActions.at(p)->isChecked();
 
             // hide panel if it is showing
             if ( m_panelActions.at(p)->isChecked() ) {
                 m_panelActions.at(p)->activate( QAction::Trigger );
             }
         }
 
         // Change Menu Item Text
         m_togglePanelVisibilityAction->setText( tr("Show &All Panels") );
         m_isPanelVisible = false;
     } else {
         for( int p=0; p<m_panelActions.size(); ++p ) {
             // show panel if it was showing before all panels were hidden
             if ( m_panelVisibility.at(p) && !m_panelActions.at(p)->isChecked() ) {
                 m_panelActions.at(p)->activate( QAction::Trigger );
             }
         }
 
         // Change Menu Item Text
         m_togglePanelVisibilityAction->setText( tr("Hide &All Panels") );
         m_isPanelVisible = true;
     }
 }
 
 void ControlView::handleTourLinkClicked(const QString& path)
 {
     QString tourPath = MarbleDirs::path( path );
     if ( !tourPath.isEmpty() ) {
         openTour( tourPath );
     }
 }
 
 void ControlView::openTour( const QString &filename )
 {
     if ( m_tourWidget->openTour( filename ) ) {
         m_tourWidget->startPlaying();
     }
 }
 
 void ControlView::closeEvent( QCloseEvent *event )
 {
     QCloseEvent newEvent;
     QCoreApplication::sendEvent( m_tourWidget, &newEvent );
 
     if ( newEvent.isAccepted() ) {
         event->accept();
     } else {
         event->ignore();
     }
 }
 
 void ControlView::dragEnterEvent(QDragEnterEvent *event)
 {
     bool success = false;
 
     const QMimeData *mimeData = event->mimeData();
 
     GeoUriParser uriParser;
 
     // prefer urls
     if (mimeData->hasUrls()) {
         // be generous and take the first usable url
         for(const QUrl& url: mimeData->urls()) {
             uriParser.setGeoUri(url.url());
             success = uriParser.parse();
             if (success) {
                 break;
             }
         }
     }
 
     // fall back to own string parsing
     if (!success && mimeData->hasText()) {
         const QString text = mimeData->text();
         // first try human readable coordinates
         GeoDataCoordinates::fromString(text, success);
         // next geo uri
         if (!success) {
             uriParser.setGeoUri(text);
             success = uriParser.parse();
         }
     }
 
     if (success) {
         event->acceptProposedAction();
     }
 }
 
 void ControlView::dropEvent(QDropEvent *event)
 {
     bool success = false;
 
     const QMimeData *mimeData = event->mimeData();
 
     // prefer urls
     if (mimeData->hasUrls()) {
         // be generous and take the first usable url
         for(const QUrl& url: mimeData->urls()) {
             success = openGeoUri(url.url());
             if (success) {
                 break;
             }
         }
     }
 
     // fall back to own string parsing
     if (!success && mimeData->hasText()) {
         const QString text = mimeData->text();
         // first try human readable coordinates
         const GeoDataCoordinates coordinates = GeoDataCoordinates::fromString(text, success);
         if (success) {
             const qreal longitude = coordinates.longitude(GeoDataCoordinates::Degree);
             const qreal latitude = coordinates.latitude(GeoDataCoordinates::Degree);
             m_marbleWidget->centerOn(longitude, latitude);
         } else {
             success = openGeoUri(text);
         }
     }
     if (success) {
         event->acceptProposedAction();
     }
 }
 
 }
 
 #include "moc_ControlView.cpp"
diff --git a/src/lib/marble/CMakeLists.txt b/src/lib/marble/CMakeLists.txt
index 9b438200c..427ae744a 100644
--- a/src/lib/marble/CMakeLists.txt
+++ b/src/lib/marble/CMakeLists.txt
@@ -1,744 +1,744 @@
 PROJECT(marblewidget)
 
 macro_optional_find_package(Phonon4Qt5 QUIET)
 marble_set_package_properties( Phonon4Qt5 PROPERTIES
     DESCRIPTION "Qt-based audio library"
     URL "https://phonon.kde.org/"
     PURPOSE "Support for playback of soundcue elements"
     TYPE OPTIONAL
 )
 if(Phonon4Qt5_FOUND)
     set(HAVE_PHONON TRUE)
 endif()
 CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config-phonon.h.cmake
                ${CMAKE_CURRENT_BINARY_DIR}/config-phonon.h)
 
 INCLUDE_DIRECTORIES(
  ${CMAKE_CURRENT_SOURCE_DIR}
  ${CMAKE_CURRENT_BINARY_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}/projections
  ${CMAKE_CURRENT_SOURCE_DIR}/routing
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/data
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/graphicsitem
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/scene
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/handlers
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/handlers/kml
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/handlers/dgml
  ${CMAKE_CURRENT_SOURCE_DIR}/geodata/parser
  ${CMAKE_CURRENT_SOURCE_DIR}/graphicsview
  ${CMAKE_CURRENT_SOURCE_DIR}/layers
  ${CMAKE_CURRENT_SOURCE_DIR}/osm
  ${CMAKE_CURRENT_SOURCE_DIR}/cloudsync
  ${CMAKE_SOURCE_DIR}/src/lib/astro
  ${ZLIB_INCLUDE_DIRS}
 )
 
 INCLUDE(geodata/CMakeLists.txt)
 INCLUDE(graphicsview/CMakeLists.txt)
 INCLUDE(layers/CMakeLists.txt)
 INCLUDE(osm/CMakeLists.txt)
 
 set(MARBLE_LIB_VERSION_MAJOR "0")
-set(MARBLE_LIB_VERSION_MINOR "26")
-set(MARBLE_LIB_VERSION_PATCH "20")
+set(MARBLE_LIB_VERSION_MINOR "27")
+set(MARBLE_LIB_VERSION_PATCH "0")
 set(MARBLE_LIB_VERSION "${MARBLE_LIB_VERSION_MAJOR}.${MARBLE_LIB_VERSION_MINOR}.${MARBLE_LIB_VERSION_PATCH}")
 set(MARBLE_ABI_VERSION "27")
 
 ########### next target ###############
 
 if(MARBLE_NO_WEBKITWIDGETS)
 add_definitions(-DMARBLE_NO_WEBKITWIDGETS)
 endif()
 
 set(marblewidget_SRCS
     ${geodata_SRCS}
     ${graphicsview_SRCS}
     ${layers_SRCS}
     ${osm_SRCS}
     blendings/Blending.cpp
     blendings/BlendingAlgorithms.cpp
     blendings/BlendingFactory.cpp
     blendings/SunLightBlending.cpp
     DownloadRegion.cpp
     DownloadRegionDialog.cpp
     LatLonBoxWidget.cpp
     MarbleWidget.cpp
     MarbleAbstractPresenter.cpp
     MarbleModel.cpp
     MarbleMap.cpp
     MarbleColors.cpp
     MapViewWidget.cpp
     CelestialSortFilterProxyModel.cpp
     FileViewWidget.cpp
     TourWidget.cpp
     FlyToEditWidget.cpp
     TourControlEditWidget.cpp
     WaitEditWidget.cpp
     SoundCueEditWidget.cpp
     RemoveItemEditWidget.cpp
     TourItemDelegate.cpp
     MapViewItemDelegate.cpp
     TourPlayback.cpp
     LegendWidget.cpp
     PlaybackItem.cpp
     PlaybackAnimatedUpdateItem.cpp
     PlaybackFlyToItem.cpp
     PlaybackSoundCueItem.cpp
     PlaybackTourControlItem.cpp
     PlaybackWaitItem.cpp
     SerialTrack.cpp
     SoundTrack.cpp
     AnimatedUpdateTrack.cpp
     CurrentLocationWidget.cpp
     MarbleNavigator.cpp
     MarbleLegendBrowser.cpp
     MarbleAboutDialog.cpp
     MarbleInputHandler.cpp
     MarbleWidgetInputHandler.cpp
     MarbleWidgetPopupMenu.cpp
     MarblePlacemarkModel.cpp
     GeoDataTreeModel.cpp
     GeoUriParser.cpp
     kdescendantsproxymodel.cpp
     BranchFilterProxyModel.cpp
     TreeViewDecoratorModel.cpp
     MarbleDebug.cpp
     Tile.cpp
     TextureTile.cpp
     TileCoordsPyramid.cpp
     TileLevelRangeWidget.cpp
     TileLoader.cpp
     QtMarbleConfigDialog.cpp
     ClipPainter.cpp
     DownloadPolicy.cpp
     DownloadQueueSet.cpp
     GeoPainter.cpp
     HttpDownloadManager.cpp
     HttpJob.cpp
     RemoteIconLoader.cpp
     LayerManager.cpp
     PluginManager.cpp
     TimeControlWidget.cpp
     AbstractFloatItem.cpp
     PopupItem.cpp
     MarbleGlobal.cpp
     MarbleDirs.cpp
     MarbleLocale.cpp
     MarblePhysics.cpp
     TileCreatorDialog.cpp
     MapThemeManager.cpp
     ViewportParams.cpp
     ViewParams.cpp
     projections/AbstractProjection.cpp
     projections/CylindricalProjection.cpp
     projections/AzimuthalProjection.cpp
     projections/SphericalProjection.cpp
     projections/EquirectProjection.cpp
     projections/MercatorProjection.cpp
     projections/GnomonicProjection.cpp
     projections/StereographicProjection.cpp
     projections/LambertAzimuthalProjection.cpp
     projections/AzimuthalEquidistantProjection.cpp
     projections/VerticalPerspectiveProjection.cpp
     VisiblePlacemark.cpp
     PlacemarkLayout.cpp
     Planet.cpp
     PlanetFactory.cpp
     Quaternion.cpp
     TextureColorizer.cpp
     TextureMapperInterface.cpp
     ScanlineTextureMapperContext.cpp
     SphericalScanlineTextureMapper.cpp
     EquirectScanlineTextureMapper.cpp
     MercatorScanlineTextureMapper.cpp
     TileScalingTextureMapper.cpp
     GenericScanlineTextureMapper.cpp
     VectorTileModel.cpp
     DiscCache.cpp
     ServerLayout.cpp
     StoragePolicy.cpp
     CacheStoragePolicy.cpp
     FileStoragePolicy.cpp
     FileStorageWatcher.cpp
     StackedTile.cpp
     TileId.cpp
     StackedTileLoader.cpp
     TileLoaderHelper.cpp
     TileCreator.cpp
     #jsonparser.cpp
     FileLoader.cpp
     FileManager.cpp
     PositionTracking.cpp
     DataMigration.cpp
     ImageF.cpp
     MovieCapture.cpp
     MovieCaptureDialog.cpp
     TourCaptureDialog.cpp
     EditPlacemarkDialog.cpp
     AddLinkDialog.cpp
     FormattedTextWidget.cpp
 
     AbstractDataPlugin.cpp
     AbstractDataPluginModel.cpp
     AbstractDataPluginItem.cpp
     AbstractWorkerThread.cpp
 
     PluginInterface.cpp
     DialogConfigurationInterface.cpp
     LayerInterface.cpp
     RenderState.cpp
     RenderPlugin.cpp
     RenderPluginInterface.cpp
     PositionProviderPlugin.cpp
     PositionProviderPluginInterface.cpp
     PlacemarkPositionProviderPlugin.cpp
     RouteSimulationPositionProviderPlugin.cpp
     MarblePluginSettingsWidget.cpp
     RenderPluginModel.cpp
     PluginAboutDialog.cpp
     PluginItemDelegate.cpp
 
     SunLocator.cpp
     MarbleClock.cpp
     SunControlWidget.cpp
     MergedLayerDecorator.cpp
 
     MathHelper.cpp
 
     LatLonEdit.cpp
     PlacemarkEditHeader.cpp
 
     MapThemeSortFilterProxyModel.cpp
 
     TemplateDocument.cpp
 
     routing/AlternativeRoutesModel.cpp
     routing/Maneuver.cpp
     routing/Route.cpp
     routing/RouteRequest.cpp
     routing/RouteSegment.cpp
     routing/RoutingModel.cpp
     routing/RoutingProfile.cpp
     routing/RoutingManager.cpp
     routing/RoutingLayer.cpp
     routing/RoutingInputWidget.cpp
     routing/RoutingWidget.cpp
     routing/RoutingProfilesWidget.cpp
     routing/RoutingProfilesModel.cpp
     routing/RoutingProfileSettingsDialog.cpp
     routing/SpeakersModel.cpp
     routing/VoiceNavigationModel.cpp
     routing/instructions/InstructionTransformation.cpp
     routing/instructions/RoutingInstruction.cpp
     routing/instructions/RoutingPoint.cpp
     routing/instructions/RoutingWaypoint.cpp
     routing/instructions/WaypointParser.cpp
 
     ParsingRunnerManager.cpp
     ReverseGeocodingRunnerManager.cpp
     RoutingRunnerManager.cpp
     SearchRunnerManager.cpp
 
     AutoNavigation.cpp
 
     SearchRunnerPlugin.cpp
     ReverseGeocodingRunnerPlugin.cpp
     RoutingRunnerPlugin.cpp
     ParseRunnerPlugin.cpp
     SearchRunner.cpp
     ReverseGeocodingRunner.cpp
     RoutingRunner.cpp
     ParsingRunner.cpp
     RunnerTask.cpp
 
     BookmarkManager.cpp
     EditBookmarkDialog.cpp
     BookmarkManagerDialog.cpp
     NewBookmarkFolderDialog.cpp
 
     PrintOptionsWidget.cpp
     ExternalEditorDialog.cpp
     GoToDialog.cpp
 
     MapWizard.cpp
     MapThemeDownloadDialog.cpp
     GeoGraphicsScene.cpp
     ElevationModel.cpp
     MarbleLineEdit.cpp
     SearchInputWidget.cpp
     SearchWidget.cpp
     kineticmodel.cpp
     NewstuffModel.cpp
     MarbleZip.cpp
 
     OsmcSymbol.cpp
 
     StyleBuilder.cpp
     
     cloudsync/CloudSyncManager.cpp
     cloudsync/RouteSyncManager.cpp
     cloudsync/OwncloudSyncBackend.cpp
     cloudsync/CloudRouteModel.cpp
     cloudsync/CloudRoutesDialog.cpp
     cloudsync/RouteItem.cpp
     cloudsync/RouteItemDelegate.cpp
     cloudsync/BookmarkSyncManager.cpp
     cloudsync/MergeItem.cpp
     cloudsync/ConflictDialog.cpp
 )
 
 
 if (MARBLE_NO_WEBKITWIDGETS)
     LIST(APPEND marblewidget_SRCS
         NullMarbleWebView.cpp
         NullTinyWebBrowser.cpp
         )
 else()
     LIST(APPEND marblewidget_SRCS
         MarbleWebView.cpp
         TinyWebBrowser.cpp
         )
 endif()
 
 if (NOT MARBLE_NO_DBUS)
     LIST(APPEND marblewidget_SRCS
         MarbleDBusInterface.cpp
         )
 endif()
 
 set (marblewidget_UI
     ${osm_UIS}
     LatLonBoxWidget.ui
     MapViewWidget.ui
     CurrentLocationWidget.ui
     FileViewWidget.ui
     TourWidget.ui
     MarbleNavigator.ui
     MarbleCacheSettingsWidget.ui
     MarbleViewSettingsWidget.ui
     MarbleNavigationSettingsWidget.ui
     TimeControlWidget.ui
     MarbleTimeSettingsWidget.ui
     MarblePluginSettingsWidget.ui
     TileCreatorDialog.ui
     TileLevelRangeWidget.ui
     MarbleAboutDialog.ui
     SunControlWidget.ui
     LatLonEdit.ui
     PlacemarkEditHeader.ui
     routing/RoutingWidget.ui
     DataMigrationWidget.ui
     EditBookmarkDialog.ui
     BookmarkManagerDialog.ui
     NewBookmarkFolderDialog.ui
     PrintOptions.ui
     ExternalEditor.ui
     GoToDialog.ui
     routing/RoutingSettingsWidget.ui
     routing/RoutingProfileSettingsDialog.ui
     MapWizard.ui
     MapThemeDownloadDialog.ui
     cloudsync/CloudRoutesDialog.ui
     MarbleCloudSyncSettingsWidget.ui
     MovieCaptureDialog.ui
     TourCaptureDialog.ui
     EditPlacemarkDialog.ui
     AddLinkDialog.ui
     FormattedTextWidget.ui
     ElevationWidget.ui
 )
 if (MARBLE_NO_WEBKITWIDGETS)
     LIST(APPEND marblewidget_UI
         NullLegendWidget.ui
         NullWebPopupWidget.ui
         )
 else()
     LIST(APPEND marblewidget_UI
         LegendWidget.ui
         WebPopupWidget.ui
         )
 endif()
 
 # FIXME: cleaner approach of src/lib/marblwidget/MarbleControlBox.* vs. marble.qrc
 qt_add_resources(marblewidget_SRCS libmarble.qrc ../../apps/marble-ui/marble.qrc)
 
 qt_wrap_ui(marblewidget_SRCS ${marblewidget_UI})
 
 add_library(marblewidget SHARED ${marblewidget_SRCS} ${SOURCES_UI_HDRS})
 
 generate_export_header(marblewidget BASE_NAME marble)
 
 
 # TODO: use PUBLIC/PRIVATE everywhere instead of LINK_PUBLIC/LINK_PRIVATE
 # once SailfishOS has cmake >= 2.8.12
 
 # link with libastro
 target_link_libraries(marblewidget LINK_PRIVATE astro)
 
 # link against zlib
 target_link_libraries(marblewidget LINK_PRIVATE ${ZLIB_LIBRARIES})
 
 # link with release version of Qt libs
 target_link_libraries(marblewidget
     LINK_PUBLIC
         Qt5::Xml
         Qt5::Gui
         Qt5::Widgets
         Qt5::Network
     LINK_PRIVATE
         Qt5::Svg
         Qt5::PrintSupport
         Qt5::Concurrent
 )
 if (NOT MARBLE_NO_WEBKITWIDGETS)
     target_link_libraries(marblewidget
         LINK_PUBLIC
             Qt5::WebKitWidgets
     )
 endif ()
 if (NOT MARBLE_NO_DBUS)
     target_link_libraries(marblewidget
         LINK_PRIVATE
             Qt5::DBus
     )
 endif ()
 if (Phonon4Qt5_FOUND)
     target_link_libraries(marblewidget
         LINK_PRIVATE
             Phonon::phonon4qt5
     )
 endif()
 
 if (APPLE)
   # TODO: PUBLIC or can be PRIVATE?
   #defined in top level makefile
   target_link_libraries(marblewidget LINK_PUBLIC ${MAC_EXTRA_LIBS} )
 endif (APPLE)
 
 # TODO: still supported?
 if (CMAKE_SYSTEM_NAME MATCHES "SunOS")
   target_link_libraries(marblewidget LINK_PUBLIC m)
 endif (CMAKE_SYSTEM_NAME MATCHES "SunOS")
 
 if(WIN32)
   # TODO: PUBLIC or can be PRIVATE?
   target_link_libraries(marblewidget LINK_PUBLIC ws2_32 imm32 winmm)
 endif(WIN32)
 
 set_target_properties(marblewidget  PROPERTIES
     EXPORT_NAME "Marble"
     OUTPUT_NAME marblewidget-qt5
     VERSION ${MARBLE_LIB_VERSION}
     SOVERSION ${MARBLE_ABI_VERSION}
     COMPILE_FLAGS "-DKML_LAZY_IMP"
 )
 
 target_include_directories(marblewidget
     INTERFACE "$<INSTALL_INTERFACE:${INCLUDE_INSTALL_DIR}>"
 )
 
 # choose the correct target install library path
 if(WIN32)
   install(TARGETS marblewidget RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX} ARCHIVE DESTINATION lib)
 elseif(APPLE)
   install(TARGETS marblewidget LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/Marble.app/Contents/MacOS/lib)
 else()
   install(TARGETS marblewidget
     EXPORT MarbleTargets
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 endif()
 
 
 ########### install headers & cmake config files ###############
 
 if (WIN32 OR APPLE)
     # TODO: find how to install & deploy library, headers and config files as bundle for development
     return()
 endif()
 
 if (MARBLE_NO_WEBKITWIDGETS)
     set(marble_WebKit
         NullMarbleWebView.h
         NullTinyWebBrowser.h
         )
 else()
     set(marble_WebKit
         MarbleWebView.h
         TinyWebBrowser.h
         )
 endif()
 
 install( FILES
     ${CMAKE_CURRENT_BINARY_DIR}/marble_export.h
     ${graphicsview_HDRS}
     ${marble_WebKit}
     AutoNavigation.h
     BookmarkManager.h
     DownloadRegion.h
     DownloadRegionDialog.h
     LatLonBoxWidget.h
     MarbleWidget.h
     MarbleMap.h
     MarbleModel.h
     MapViewWidget.h
     CelestialSortFilterProxyModel.h
     LegendWidget.h
     FileViewWidget.h
     TourWidget.h
     FlyToEditWidget.h
     TourControlEditWidget.h
     WaitEditWidget.h
     SoundCueEditWidget.h
     RemoveItemEditWidget.h
     TourItemDelegate.h
     MapViewItemDelegate.h
     TourPlayback.h
     CurrentLocationWidget.h
     MarbleNavigator.h
     AbstractFloatItem.h
     MapThemeManager.h
     MarbleAboutDialog.h
     MarbleInputHandler.h
     MarbleWidgetInputHandler.h
     MarbleWidgetPopupMenu.h
     TileId.h
     TileCoordsPyramid.h
     TileLevelRangeWidget.h
     QtMarbleConfigDialog.h
     MarbleMath.h
     MarbleColors.h
     MarbleGlobal.h
     MarbleLocale.h
     MarbleDebug.h
     MarbleDirs.h
     GeoPainter.h
     HttpDownloadManager.h
     TileCreatorDialog.h
     ViewportParams.h
     projections/AbstractProjection.h
     PositionTracking.h
     Quaternion.h
     SunLocator.h
     ClipPainter.h
     GeoGraphicsScene.h
     GeoDataTreeModel.h
     geodata/data/GeoDataAbstractView.h
     geodata/data/GeoDataAccuracy.h
     geodata/data/GeoDataBalloonStyle.h
     geodata/data/GeoDataColorStyle.h
     geodata/data/GeoDataContainer.h
     geodata/data/GeoDataCoordinates.h
     geodata/data/GeoDataDocument.h
     geodata/data/GeoDataFeature.h
     geodata/data/GeoDataFolder.h
     geodata/data/GeoDataGeometry.h
     geodata/data/GeoDataGroundOverlay.h
     geodata/data/GeoDataHotSpot.h
     geodata/data/GeoDataIconStyle.h
     geodata/data/GeoDataItemIcon.h
     geodata/data/GeoDataLabelStyle.h
     geodata/data/GeoDataLatLonAltBox.h
     geodata/data/GeoDataLatLonBox.h
     geodata/data/GeoDataLatLonQuad.h
     geodata/data/GeoDataLinearRing.h
     geodata/data/GeoDataLineString.h
     geodata/data/GeoDataLineStyle.h
     geodata/data/GeoDataListStyle.h
     geodata/data/GeoDataLod.h
     geodata/data/GeoDataLookAt.h
     geodata/data/GeoDataOverlay.h
     geodata/data/GeoDataMultiGeometry.h
     geodata/data/GeoDataObject.h
     geodata/data/GeoDataPlacemark.h
     geodata/data/GeoDataPoint.h
     geodata/data/GeoDataPolygon.h
     geodata/data/GeoDataPolyStyle.h
     geodata/data/GeoDataRelation.h
     geodata/data/GeoDataRegion.h
     geodata/data/GeoDataSnippet.h
     geodata/data/GeoDataStyle.h
     geodata/data/GeoDataStyleMap.h
     geodata/data/GeoDataStyleSelector.h
     geodata/data/GeoDataTrack.h
     geodata/data/GeoDataTimeSpan.h
     geodata/data/GeoDataTimeStamp.h
     geodata/data/GeoDataTimePrimitive.h
     geodata/data/Serializable.h
     geodata/geodata_export.h
     geodata/parser/GeoDocument.h
     geodata/parser/GeoDataTypes.h
     geodata/writer/GeoWriter.h
     routing/RoutingWidget.h
     routing/RoutingManager.h
     TileCreator.h
     PluginManager.h
     PluginInterface.h
     DialogConfigurationInterface.h
     PositionProviderPlugin.h
     PositionProviderPluginInterface.h
     RenderPlugin.h
     RenderPluginInterface.h
     ParsingRunnerManager.h
     ReverseGeocodingRunnerManager.h
     RoutingRunnerManager.h
     SearchRunnerManager.h
     ParsingRunner.h
     SearchRunner.h
     ReverseGeocodingRunner.h
     RoutingRunner.h
     SearchRunnerPlugin.h
     ReverseGeocodingRunnerPlugin.h
     RoutingRunnerPlugin.h
     ParseRunnerPlugin.h
     LayerInterface.h
     RenderState.h
     PluginAboutDialog.h
     Planet.h
     PlanetFactory.h
     EditPlacemarkDialog.h
     AddLinkDialog.h
     FormattedTextWidget.h
 
     AbstractDataPlugin.h
     AbstractDataPluginModel.h
     AbstractDataPluginItem.h
     AbstractWorkerThread.h
 
     LatLonEdit.h
     PlacemarkEditHeader.h
     MapWizard.h
     MapThemeDownloadDialog.h
     ElevationModel.h
 
     routing/AlternativeRoutesModel.h
     routing/Route.h
     routing/Maneuver.h
     routing/RouteRequest.h
     routing/RouteSegment.h
     routing/RoutingManager.h
     routing/RoutingModel.h
     routing/RoutingProfile.h
 
     OsmcSymbol.h
 
     DESTINATION ${INCLUDE_INSTALL_DIR}/marble
 )
 
 
 ########### CMake Config files ###############
 
 include(CMakePackageConfigHelpers)
 
 set(MARBLE_CMAKECONFIGNAME Marble)
 set(MARBLE_INSTALL_CMAKECONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/${MARBLE_CMAKECONFIGNAME})
 
 configure_package_config_file(MarbleConfig.cmake.in
     ${CMAKE_CURRENT_BINARY_DIR}/${MARBLE_CMAKECONFIGNAME}Config.cmake
     INSTALL_DESTINATION ${MARBLE_INSTALL_CMAKECONFIGDIR}
 )
 
 write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${MARBLE_CMAKECONFIGNAME}ConfigVersion.cmake
     VERSION ${MARBLE_LIB_VERSION}
     COMPATIBILITY SameMajorVersion
 )
 
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/${MARBLE_CMAKECONFIGNAME}Config.cmake
     ${CMAKE_CURRENT_BINARY_DIR}/${MARBLE_CMAKECONFIGNAME}ConfigVersion.cmake
 
     DESTINATION ${MARBLE_INSTALL_CMAKECONFIGDIR}
 )
 
 install(
     EXPORT MarbleTargets
     FILE ${MARBLE_CMAKECONFIGNAME}Targets.cmake
     DESTINATION ${MARBLE_INSTALL_CMAKECONFIGDIR}
 )
 
 
 ########### Qt Pri file ###############
 
 # Where the pri file is installed is defined by the following rules, with decreasing priority:
 # * MARBLE_PRI_INSTALL_USE_QT_SYS_PATHS=TRUE:
 #   pri file will be installed with the dirs of the Qt installation used
 # * MARBLE_PRI_INSTALL_DIR=some-relative-or-absolute-path
 #   if set will be used as given
 # * installation prefix = Qt installation prefix:
 #   pri file will be installed with the dirs of the Qt installation used
 # * otherwise:
 #   pri file will be installed in mkspecs/modules in the installation prefix
 
 get_target_property(PRI_LIB_NAME marblewidget OUTPUT_NAME)
 
 set(PRI_ABS_INCLUDE_INSTALL_DIR "${INCLUDE_INSTALL_DIR}")
 if(NOT IS_ABSOLUTE "${PRI_ABS_INCLUDE_INSTALL_DIR}")
     set(PRI_ABS_INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${PRI_ABS_INCLUDE_INSTALL_DIR}")
 endif()
 
 set(PRI_ABS_LIB_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}")
 if(NOT IS_ABSOLUTE "${PRI_ABS_LIB_INSTALL_DIR}")
     set(PRI_ABS_LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/${PRI_ABS_LIB_INSTALL_DIR}")
 endif()
 
 set(PRI_DEPS "xml gui widgets network")
 if (NOT MARBLE_NO_WEBKITWIDGETS)
     set(PRI_DEPS "${PRI_DEPS} webkitwidgets")
 endif()
 
 file(GENERATE
     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/qt_Marble.pri
     CONTENT
 "QT.Marble.VERSION = ${MARBLE_LIB_VERSION}
 QT.Marble.MAJOR_VERSION = ${MARBLE_LIB_VERSION_MAJOR}
 QT.Marble.MINOR_VERSION = ${MARBLE_LIB_VERSION_MINOR}
 QT.Marble.PATCH_VERSION = ${MARBLE_LIB_VERSION_PATCH}
 QT.Marble.name = ${PRI_LIB_NAME}
 QT.Marble.defines =
 QT.Marble.includes = ${PRI_ABS_INCLUDE_INSTALL_DIR}
 QT.Marble.private_includes =
 QT.Marble.libs = ${PRI_ABS_LIB_INSTALL_DIR}
 QT.Marble.depends = ${PRI_DEPS}
 "
 )
 
 # detect which folder the pri file should be installed into
 get_target_property(QMAKE_EXECUTABLE Qt5::qmake LOCATION)
 
 function(query_qmake result_variable qt_variable)
     execute_process(
         COMMAND ${QMAKE_EXECUTABLE} -query "${qt_variable}"
         RESULT_VARIABLE return_code
         OUTPUT_VARIABLE output
     )
     if(return_code EQUAL 0)
         string(STRIP "${output}" output)
         file(TO_CMAKE_PATH "${output}" output_path)
         set(${result_variable} "${output_path}" PARENT_SCOPE)
     else()
         message(WARNING "Failed call: ${QMAKE_EXECUTABLE} -query \"${qt_variable}\"")
         message(FATAL_ERROR "QMake call failed: ${return_code}")
     endif()
 endfunction()
 
 # if going to be installed into same prefix as Qt, then also use same folder
 set(IS_SHARED_INSTALL_PREFIX FALSE)
 if(NOT DEFINED MARBLE_PRI_INSTALL_USE_QT_SYS_PATHS)
     query_qmake(qt_install_prefix_dir QT_INSTALL_PREFIX)
     if(qt_install_prefix_dir STREQUAL "${CMAKE_INSTALL_PREFIX}")
         set(IS_SHARED_INSTALL_PREFIX TRUE)
     endif()
 endif()
 
 if(MARBLE_PRI_INSTALL_USE_QT_SYS_PATHS OR IS_SHARED_INSTALL_PREFIX)
     query_qmake(qt_host_data_dir QT_HOST_DATA)
     set(PRI_INSTALL_DIR ${qt_host_data_dir}/mkspecs/modules)
 else()
     set(PRI_INSTALL_DIR mkspecs/modules)
 endif()
 set(MARBLE_PRI_INSTALL_DIR "${PRI_INSTALL_DIR}" CACHE PATH "The directory where the Marble pri file will be installed to.")
 
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/qt_Marble.pri
     DESTINATION  ${MARBLE_PRI_INSTALL_DIR}
 )
diff --git a/src/lib/marble/MarbleGlobal.h b/src/lib/marble/MarbleGlobal.h
index 8c13b3f52..0c6422fbb 100644
--- a/src/lib/marble/MarbleGlobal.h
+++ b/src/lib/marble/MarbleGlobal.h
@@ -1,310 +1,310 @@
 //
 // This file is part of the Marble Virtual Globe.
 //
 // This program is free software licensed under the GNU LGPL. You can
 // find a copy of this license in LICENSE.txt in the top directory of
 // the source code.
 //
 // Copyright 2007-2009 Torsten Rahn <tackat@kde.org>
 // Copyright 2007      Inge Wallin  <ingwa@kde.org>
 //
 
 #ifndef MARBLE_GLOBAL_H
 #define MARBLE_GLOBAL_H
 
 
 #include <cmath>
 
 #include <QString>
 
 #include "marble_export.h"
 #include "MarbleColors.h"
 
 // #define QT_STRICT_ITERATORS
 
 
 namespace Marble
 {
 
 enum TessellationFlag {
     NoTessellation = 0x0,
     Tessellate = 0x1, 
     RespectLatitudeCircle = 0x2,
     FollowGround = 0x4,
     PreventNodeFiltering = 0x8
 };
 
 Q_DECLARE_FLAGS(TessellationFlags, TessellationFlag)
 
 /**
  * @brief This enum is used to choose the projection shown in the view.
  */
 enum Projection { 
     Spherical,          ///< Spherical projection ("Orthographic")
     Equirectangular,    ///< Flat projection ("plate carree")
     Mercator,           ///< Mercator projection
     Gnomonic,           ///< Gnomonic projection
     Stereographic,      ///< Stereographic projection
     LambertAzimuthal,   ///< Lambert Azimuthal Equal-Area projection
     AzimuthalEquidistant,   ///< Azimuthal Equidistant projection
     VerticalPerspective ///< Vertical perspective projection
     // NOTE: MarbleWidget::setProjection(int) relies on VerticalPerspective being the last
     // value above. Adjust that method if you do changes here
 };
 
 /**
  * @brief This enum is used to choose the dimension.
  */
 enum Dimension {
     Latitude,             ///< Latitude
     Longitude            ///< Longitude
 };
 
 Q_DECLARE_FLAGS(Dimensions, Dimension)
 
 /**
  * @brief This enum is used to choose the unit chosen to measure angles.
  */
 enum AngleUnit {
     DMSDegree,          ///< Degrees in DMS notation
     DecimalDegree,      ///< Degrees in decimal notation
     UTM                 ///< UTM
 };
 
 /**
  * @brief This enum is used to choose context in which map quality gets used.
  */
 enum ViewContext {
     Still,              ///< still image
     Animation           ///< animated view (e.g. while rotating the globe)
 }; 
 
 /**
  * @brief This enum is used to choose the map quality shown in the view.
  */
 enum MapQuality {
     OutlineQuality,     ///< Only a wire representation is drawn
     LowQuality,         ///< Low resolution (e.g. interlaced)
     NormalQuality,      ///< Normal quality
     HighQuality,        ///< High quality (e.g. antialiasing for lines)
     PrintQuality        ///< Print quality
 }; 
 
 /**
  * @brief This enum is used to specify the proxy that is used.
  */
 enum ProxyType {
     HttpProxy,          ///< Uses an Http proxy
     Socks5Proxy         ///< Uses a Socks5Proxy
 };
 
 /**
  * @brief This enum is used to choose the localization of the labels.
  */
 enum LabelPositionFlag {
     NoLabel = 0x0,
     LineStart = 0x1,
     LineCenter = 0x2,
     LineEnd = 0x4,
     IgnoreXMargin = 0x8,
     IgnoreYMargin = 0x10,
     FollowLine = 0x20
 };
 
 Q_DECLARE_FLAGS(LabelPositionFlags, LabelPositionFlag)
 
 /**
  * @brief This enum is used to choose the localization of the labels.
  */
 enum LabelLocalization {
     CustomAndNative,    ///< Custom and native labels
     Custom,             ///< Shows the name in the user's language
     Native              ///< Display the name in the official language and  
                         ///  glyphs of the labeled place. 
 };
 
 /**
  * @brief This enum is used to choose how the globe behaves while dragging.
  */
 enum DragLocation {
     KeepAxisVertically, ///< Keep planet axis vertically
     FollowMousePointer  ///< Follow mouse pointer exactly
 };
 
 /**
  * @brief This enum is used to choose how the globe behaves while dragging.
  */
 enum OnStartup {
     ShowHomeLocation,   ///< Show home location on startup
     LastLocationVisited ///< Show last location visited on quit
 };
 
 enum AltitudeMode {
     ClampToGround,      ///< Altitude always sticks to ground level
     RelativeToGround,   ///< Altitude is always given relative to ground level
     Absolute,            ///< Altitude is given relative to the sealevel
     RelativeToSeaFloor,  ///< Altitude is given relative to the sea floor
     ClampToSeaFloor      ///< Altitude always sticks to sea floor
 };
 
 enum Pole {
     AnyPole,             ///< Any pole
     NorthPole,           ///< Only North Pole
     SouthPole            ///< Only South Pole
 };
 
 /**
  * @brief This enum is used to describe the type of download
  */
 enum DownloadUsage {
     DownloadBulk,       ///< Bulk download, for example "File/Download region"
     DownloadBrowse      ///< Browsing mode, normal operation of Marble, like a web browser
 };
 
 /** 
  * @brief Describes possible flight mode (interpolation between source
  *        and target camera positions)
  */
 enum FlyToMode {
     Automatic, ///< A sane value is chosen automatically depending on animation settings and the action
     Instant, ///< Change camera position immediately (no interpolation)
     Linear, ///< Linear interpolation of lon, lat and distance to ground
     Jump ///< Linear interpolation of lon and lat, distance increases towards the middle point, then decreases    
 };
 
 /**
  * @brief Search mode: Global (worldwide) versus area (local, regional) search
  */
 enum SearchMode {
     GlobalSearch, ///< Search a whole planet
     AreaSearch ///< Search a certain region of a planet (e.g. visible region)
 };
 
 /**
  * @brief
  */
 enum RenderStatus {
     Complete, ///< All data is there and up to date
     WaitingForUpdate, ///< Rendering is based on complete, but outdated data, data update was requested
     WaitingForData, ///< Rendering is based on no or partial data, more data was requested (e.g. pending network queries)
     Incomplete ///< Data is missing and some error occurred when trying to retrieve it (e.g. network failure)
 };
 
 const int defaultLevelZeroColumns = 2;
 const int defaultLevelZeroRows = 1;
 
 // Conversion Metric / Imperial System: km vs. miles
 const qreal MI2KM = 1.609344;
 const qreal KM2MI = 1.0 / MI2KM;
 
 // Conversion Nautical / Imperial System: nm vs. km
 const qreal NM2KM = 1.852;
 const qreal KM2NM = 1.0 / NM2KM;
 const qreal NM2FT = 6080; // nm feet
 
 // Conversion Metric / Imperial System: meter vs. feet
 const qreal M2FT = 3.2808;
 const qreal FT2M = 1.0 / M2FT;
 
 // Conversion Metric / Imperial System: meter vs inch
 const qreal M2IN = 39.3701;
 const qreal IN2M = 1.0 / M2IN;
 
 // Conversion Metric / Imperial System: meter vs yard
 const qreal M2YD = 1.09361;
 const qreal YD2M = 1.0 / M2YD;
 
 // Conversion meter vs millimeter
 const qreal M2MM = 1000.0;
 const qreal MM2M = 1.0 / M2MM;
 
 // Conversion meter vs centimeter
 const qreal M2CM = 100.0;
 const qreal CM2M = 1.0 / M2CM;
 
 // Conversion degree vs. radians
 const qreal DEG2RAD = M_PI / 180.0;
 const qreal RAD2DEG = 180.0 / M_PI;
 
 // Conversion meter vs kilometer
 const qreal KM2METER = 1000.0;
 const qreal METER2KM = 1.0 / KM2METER;
 
 //Conversion hour vs minute
 const qreal HOUR2MIN = 60.0;
 const qreal MIN2HOUR = 1.0 / HOUR2MIN;
 
 //Conversion (time) minute vs second
 const qreal MIN2SEC = 60.0;
 const qreal SEC2MIN = 1.0 / MIN2SEC;
 
 //Conversion hour vs second
 const qreal HOUR2SEC = 3600.0;
 const qreal SEC2HOUR = 1.0 / HOUR2SEC;
 
 // Version definitions to use with an external application (as digiKam)
 
 // String for about dialog and http user agent
 // FIXME: check if blanks are allowed in user agent version numbers
-const QString MARBLE_VERSION_STRING = QString::fromLatin1( "0.26.20 (0.27 development version)" );
+const QString MARBLE_VERSION_STRING = QString::fromLatin1( "0.27.0 (stable release)" );
 
 // API Version id:
 // form : 0xMMmmpp
 //        MM = major revision.
 //        mm = minor revision.
 //        pp = patch revision.
-#define MARBLE_VERSION 0x001a14
+#define MARBLE_VERSION 0x001b00
 
 static const char NOT_AVAILABLE[] = QT_TRANSLATE_NOOP("Marble", "not available");
 
 const int tileDigits = 6;
 
 // Average earth radius in m
 // Deprecated: Please use model()->planetRadius() instead.
 const qreal EARTH_RADIUS = 6378137.0;
 
 // Maximum level of base tiles
 const int maxBaseTileLevel = 4;
 
 // Default size (width and height) of tiles
 const unsigned int c_defaultTileSize = 675;
 
 class MarbleGlobalPrivate;
 class MarbleLocale;
 
 class  MARBLE_EXPORT MarbleGlobal
 {
  public:
     static MarbleGlobal * getInstance();
     ~MarbleGlobal();
 
     MarbleLocale * locale() const;
     
     enum Profile {
         Default = 0x0,
         SmallScreen = 0x1,
         HighResolution = 0x2
     };
     
     Q_DECLARE_FLAGS( Profiles, Profile )
 
     Profiles profiles() const;
     void setProfiles( Profiles profiles );
 
     /** @deprecated Profiles are detected automatically now. This only returns profiles() anymore */
     MARBLE_DEPRECATED static Profiles detectProfiles();
     
  private:
     MarbleGlobal();
 
     Q_DISABLE_COPY( MarbleGlobal )
     MarbleGlobalPrivate  * const d;
 };
 
 }
 
 Q_DECLARE_OPERATORS_FOR_FLAGS( Marble::TessellationFlags )
 Q_DECLARE_OPERATORS_FOR_FLAGS( Marble::LabelPositionFlags )
 Q_DECLARE_OPERATORS_FOR_FLAGS( Marble::MarbleGlobal::Profiles )
 
 #endif