lib/marble/QtMarbleConfigDialog.cpp

0001 // SPDX-License-Identifier: LGPL-2.1-or-later
0002 //
0003 // SPDX-FileCopyrightText: 2009 Bastian Holst <bastianholst@gmx.de>
0004 // SPDX-FileCopyrightText: 2012 Mohammed Nafees <nafees.technocool@gmail.com>
0005 //
0006
0007 // Own
0008 #include "QtMarbleConfigDialog.h"
0009
0010 #include "ui_MarbleCacheSettingsWidget.h"
0011 #include "ui_MarbleViewSettingsWidget.h"
0012 #include "ui_MarbleNavigationSettingsWidget.h"
0013 #include "ui_MarbleTimeSettingsWidget.h"
0014 #include "ui_MarbleCloudSyncSettingsWidget.h"
0015
0016 // Qt
0017 #include <QSettings>
0018 #include <QNetworkProxy>
0019 #include <QApplication>
0020 #include <QDialogButtonBox>
0021 #include <QTabWidget>
0022 #include <QVBoxLayout>
0023 #include <QWidget>
0024 #include <QDateTime>
0025 #include <QTimer>
0026
0027 // Marble
0028 #include "MarbleDebug.h"
0029 #include "MarbleDirs.h"
0030 #include "MarblePluginSettingsWidget.h"
0031 #include "MarbleWidget.h"
0032 #include "MarbleModel.h"
0033 #include "RenderPlugin.h"
0034 #include "RenderPluginModel.h"
0035 #include "MarbleClock.h"
0036 #include "routing/RoutingProfilesWidget.h"
0037 #include "BookmarkSyncManager.h"
0038 #include "CloudSyncManager.h"
0039
0040 namespace Marble
0041 {
0042
0043 class QtMarbleConfigDialogPrivate
0044 {
0045  public:
0046     QtMarbleConfigDialogPrivate( MarbleWidget *marbleWidget, CloudSyncManager *cloudSyncManager )
0047         : ui_viewSettings(),
0048           ui_navigationSettings(),
0049           ui_timeSettings(),
0050           ui_cacheSettings(),
0051           w_pluginSettings( nullptr ),
0052           m_cloudSyncStatusLabel( nullptr ),
0053           m_marbleWidget( marbleWidget ),
0054           m_syncManager( cloudSyncManager ? cloudSyncManager->bookmarkSyncManager() : nullptr ),
0055           m_cloudSyncManager(cloudSyncManager),
0056           m_pluginModel()
0057     {
0058     }
0059
0060     Ui::MarbleViewSettingsWidget       ui_viewSettings;
0061     Ui::MarbleNavigationSettingsWidget ui_navigationSettings;
0062     Ui::MarbleTimeSettingsWidget       ui_timeSettings;
0063     Ui::MarbleCacheSettingsWidget      ui_cacheSettings;
0064     Ui::MarbleCloudSyncSettingsWidget  ui_cloudSyncSettings;
0065     MarblePluginSettingsWidget         *w_pluginSettings;
0066
0067     QSettings m_settings;
0068
0069     QLabel *m_cloudSyncStatusLabel;
0070
0071     MarbleWidget *const m_marbleWidget;
0072     BookmarkSyncManager *const m_syncManager;
0073     CloudSyncManager *const m_cloudSyncManager;
0074
0075     RenderPluginModel m_pluginModel;
0076
0077     QHash< int, int > m_timezone;
0078 };
0079
0080 QtMarbleConfigDialog::QtMarbleConfigDialog(MarbleWidget *marbleWidget, CloudSyncManager *cloudSyncManager,
0081                                            QWidget *parent )
0082     : QDialog( parent ),
0083       d( new QtMarbleConfigDialogPrivate( marbleWidget, cloudSyncManager ) )
0084 {
0085     QTabWidget *tabWidget = new QTabWidget( this );
0086     QDialogButtonBox *buttons =
0087     new QDialogButtonBox( QDialogButtonBox::Ok
0088                         | QDialogButtonBox::Apply
0089                         | QDialogButtonBox::Cancel,
0090                           Qt::Horizontal,
0091                           this );
0092
0093     // Connect the signals of the ButtonBox
0094     // to the corresponding slots of the dialog.
0095     connect( buttons, SIGNAL(accepted()), this, SLOT(accept()) ); // Ok
0096     connect( buttons, SIGNAL(rejected()), this, SLOT(reject()) ); // Cancel
0097     connect( buttons->button( QDialogButtonBox::Apply ),SIGNAL(clicked()),
0098              this, SLOT(writeSettings()) );                         // Apply
0099     // If the dialog is accepted. Save the settings.
0100     connect( this, SIGNAL(accepted()), this, SLOT(writeSettings()) );
0101
0102     // view page
0103     QWidget *w_viewSettings = new QWidget( this );
0104
0105     d->ui_viewSettings.setupUi( w_viewSettings );
0106     tabWidget->addTab( w_viewSettings, tr( "View" ) );
0107
0108     d->ui_viewSettings.kcfg_labelLocalization->hide();
0109     d->ui_viewSettings.label_labelLocalization->hide();
0110
0111     // navigation page
0112     QWidget *w_navigationSettings = new QWidget( this );
0113
0114     d->ui_navigationSettings.setupUi( w_navigationSettings );
0115     tabWidget->addTab( w_navigationSettings, tr( "Navigation" ) );
0116     d->ui_navigationSettings.kcfg_dragLocation->hide();
0117     d->ui_navigationSettings.label_dragLocation->hide();
0118
0119     // cache page
0120     QWidget *w_cacheSettings = new QWidget( this );
0121
0122     d->ui_cacheSettings.setupUi( w_cacheSettings );
0123     tabWidget->addTab( w_cacheSettings, tr( "Cache and Proxy" ) );
0124     // Forwarding clear button signals
0125     connect( d->ui_cacheSettings.button_clearVolatileCache, SIGNAL(clicked()), SIGNAL(clearVolatileCacheClicked()) );
0126     connect( d->ui_cacheSettings.button_clearPersistentCache, SIGNAL(clicked()), SIGNAL(clearPersistentCacheClicked()) );
0127
0128     // time page
0129     QWidget *w_timeSettings = new QWidget( this );
0130     d->ui_timeSettings.setupUi( w_timeSettings );
0131     tabWidget->addTab( w_timeSettings, tr( "Date and Time" ) );
0132
0133     // routing page
0134     QWidget *w_routingSettings = new RoutingProfilesWidget( marbleWidget->model() );
0135     tabWidget->addTab( w_routingSettings, tr( "Routing" ) );
0136
0137     // plugin page
0138     d->m_pluginModel.setRenderPlugins( d->m_marbleWidget->renderPlugins() );
0139     d->w_pluginSettings = new MarblePluginSettingsWidget( this );
0140     d->w_pluginSettings->setModel( &d->m_pluginModel );
0141     d->w_pluginSettings->setObjectName( "plugin_page" );
0142     tabWidget->addTab( d->w_pluginSettings, tr( "Plugins" ) );
0143
0144     // Setting the icons for the plugin dialog.
0145     d->w_pluginSettings->setAboutIcon(QIcon(QStringLiteral(":/icons/help-about.png")));
0146     d->w_pluginSettings->setConfigIcon(QIcon(QStringLiteral(":/icons/settings-configure.png")));
0147
0148     connect( this, SIGNAL(rejected()), &d->m_pluginModel, SLOT(retrievePluginState()) );
0149     connect( this, SIGNAL(accepted()), &d->m_pluginModel, SLOT(applyPluginState()) );
0150
0151     QWidget *w_cloudSyncSettings = new QWidget( this );
0152     d->ui_cloudSyncSettings.setupUi( w_cloudSyncSettings );
0153     tabWidget->addTab( w_cloudSyncSettings, tr( "Synchronization" ) );
0154     d->ui_cloudSyncSettings.button_syncNow->setEnabled( syncBookmarks() );
0155     d->m_cloudSyncStatusLabel = d->ui_cloudSyncSettings.cloudSyncStatus;
0156     connect( d->ui_cloudSyncSettings.button_syncNow, SIGNAL(clicked()), SIGNAL(syncNowClicked()) );
0157     connect( d->ui_cloudSyncSettings.testLoginButton, SIGNAL(clicked()), this, SLOT(updateCloudSyncCredentials()) );
0158
0159     if ( d->m_syncManager ) {
0160         connect(d->m_syncManager, SIGNAL(syncComplete()), this, SLOT(updateLastSync()));
0161         updateLastSync();
0162     }
0163     if ( d->m_cloudSyncManager ) {
0164         connect( d->m_cloudSyncManager, SIGNAL(statusChanged(QString)),
0165                  this, SLOT(updateCloudSyncStatus(QString)));
0166     }
0167
0168     // Layout
0169     QVBoxLayout *layout = new QVBoxLayout( this );
0170     layout->addWidget( tabWidget );
0171     layout->addWidget( buttons );
0172
0173     this->setLayout( layout );
0174
0175     // When the settings have been changed, write to disk.
0176     connect( this, SIGNAL(settingsChanged()), this, SLOT(syncSettings()) );
0177
0178     initializeCustomTimezone();
0179 }
0180
0181 QtMarbleConfigDialog::~QtMarbleConfigDialog()
0182 {
0183     delete d;
0184 }
0185
0186 void QtMarbleConfigDialog::syncSettings()
0187 {
0188     d->m_settings.sync();
0189
0190     QNetworkProxy proxy;
0191
0192     // Make sure that no proxy is used for an empty string or the default value:
0193     if (proxyUrl().isEmpty() || proxyUrl() == QLatin1String("http://")) {
0194         proxy.setType( QNetworkProxy::NoProxy );
0195     } else {
0196         if ( proxyType() == Marble::Socks5Proxy ) {
0197             proxy.setType( QNetworkProxy::Socks5Proxy );
0198         }
0199         else if ( proxyType() == Marble::HttpProxy ) {
0200             proxy.setType( QNetworkProxy::HttpProxy );
0201         }
0202         else {
0203             mDebug() << "Unknown proxy type! Using Http Proxy instead.";
0204             proxy.setType( QNetworkProxy::HttpProxy );
0205         }
0206     }
0207
0208     proxy.setHostName( proxyUrl() );
0209     proxy.setPort( proxyPort() );
0210
0211     if ( proxyAuth() ) {
0212         proxy.setUser( proxyUser() );
0213         proxy.setPassword( proxyPass() );
0214     }
0215
0216     QNetworkProxy::setApplicationProxy(proxy);
0217 }
0218
0219 void QtMarbleConfigDialog::updateCloudSyncCredentials()
0220 {
0221     if ( d->m_cloudSyncManager ) {
0222         d->m_cloudSyncManager->setOwncloudCredentials(
0223                     d->ui_cloudSyncSettings.kcfg_owncloudServer->text(),
0224                     d->ui_cloudSyncSettings.kcfg_owncloudUsername->text(),
0225                     d->ui_cloudSyncSettings.kcfg_owncloudPassword->text() );
0226     }
0227 }
0228
0229 void QtMarbleConfigDialog::disableSyncNow()
0230 {
0231     if ( !d->m_syncManager ) {
0232         return;
0233     }
0234
0235     d->ui_cloudSyncSettings.button_syncNow->setDisabled(true);
0236
0237     QTimer *timeoutTimer = new QTimer(this);
0238     connect(timeoutTimer, SIGNAL(timeout()),
0239             timeoutTimer, SLOT(stop()));
0240     connect(timeoutTimer, SIGNAL(timeout()),
0241             this, SLOT(enableSyncNow()));
0242
0243     connect(d->m_syncManager, SIGNAL(syncComplete()),
0244             this, SLOT(enableSyncNow()));
0245     connect(d->m_syncManager, SIGNAL(syncComplete()),
0246             timeoutTimer, SLOT(stop()));
0247     connect(d->m_syncManager, SIGNAL(syncComplete()),
0248             timeoutTimer, SLOT(deleteLater()));
0249
0250     timeoutTimer->start(30*1000); // 30 sec
0251 }
0252
0253 void QtMarbleConfigDialog::enableSyncNow()
0254 {
0255     if ( !d->m_syncManager ) {
0256         return;
0257     }
0258
0259     d->ui_cloudSyncSettings.button_syncNow->setEnabled(true);
0260 }
0261
0262 void QtMarbleConfigDialog::updateLastSync()
0263 {
0264     if ( !d->m_syncManager ) {
0265         return;
0266     }
0267
0268     if (!d->m_syncManager->lastSync().isValid()) {
0269         d->ui_cloudSyncSettings.labelLastSync->setText(tr("Never synchronized."));
0270         return;
0271     }
0272
0273     const QString title = tr("Last synchronization: %1")
0274             .arg(d->m_syncManager->lastSync().toString());
0275
0276     d->ui_cloudSyncSettings.labelLastSync->setText(title);
0277 }
0278
0279 void QtMarbleConfigDialog::readSettings()
0280 {
0281     // Sync settings to make sure that we read the current settings.
0282     syncSettings();
0283
0284     // View
0285     d->ui_viewSettings.kcfg_distanceUnit->setCurrentIndex( measurementSystem() );
0286     d->ui_viewSettings.kcfg_angleUnit->setCurrentIndex( angleUnit() );
0287     d->ui_viewSettings.kcfg_stillQuality->setCurrentIndex( stillQuality() );
0288     d->ui_viewSettings.kcfg_animationQuality->setCurrentIndex( animationQuality() );
0289     d->ui_viewSettings.kcfg_labelLocalization->setCurrentIndex( Marble::Native );
0290     d->ui_viewSettings.kcfg_mapFont->setCurrentFont( mapFont() );
0291
0292     // Navigation
0293     d->ui_navigationSettings.kcfg_dragLocation->setCurrentIndex( Marble::KeepAxisVertically );
0294     d->ui_navigationSettings.kcfg_onStartup->setCurrentIndex( onStartup() );
0295     d->ui_navigationSettings.kcfg_inertialEarthRotation->setChecked( inertialEarthRotation() );
0296     d->ui_navigationSettings.kcfg_mouseViewRotation->setChecked( mouseViewRotation() );
0297     d->ui_navigationSettings.kcfg_animateTargetVoyage->setChecked( animateTargetVoyage() );
0298     int editorIndex = 0;
0299     if (externalMapEditor() == QLatin1String("potlatch")) {
0300         editorIndex = 1;
0301     } else if (externalMapEditor() == QLatin1String("josm")) {
0302         editorIndex = 2;
0303     } else if (externalMapEditor() == QLatin1String("merkaartor")) {
0304         editorIndex = 3;
0305     }
0306     d->ui_navigationSettings.kcfg_externalMapEditor->setCurrentIndex( editorIndex );
0307
0308     // Cache
0309     d->ui_cacheSettings.kcfg_volatileTileCacheLimit->setValue( volatileTileCacheLimit() );
0310     d->ui_cacheSettings.kcfg_persistentTileCacheLimit->setValue( persistentTileCacheLimit() );
0311     d->ui_cacheSettings.kcfg_proxyUrl->setText( proxyUrl() );
0312     d->ui_cacheSettings.kcfg_proxyPort->setValue( proxyPort() );
0313     d->ui_cacheSettings.kcfg_proxyUser->setText( proxyUser() );
0314     d->ui_cacheSettings.kcfg_proxyPass->setText( proxyPass() );
0315     d->ui_cacheSettings.kcfg_proxyType->setCurrentIndex( proxyType() );
0316     d->ui_cacheSettings.kcfg_proxyAuth->setChecked( proxyAuth() );
0317
0318     // Time
0319     d->ui_timeSettings.kcfg_systemTimezone->setChecked( systemTimezone() );
0320     d->ui_timeSettings.kcfg_customTimezone->setChecked( customTimezone() );
0321     d->ui_timeSettings.kcfg_chosenTimezone->setCurrentIndex( chosenTimezone() );
0322     d->ui_timeSettings.kcfg_utc->setChecked( UTC() );
0323     d->ui_timeSettings.kcfg_systemTime->setChecked( systemTime() );
0324     d->ui_timeSettings.kcfg_lastSessionTime->setChecked( lastSessionTime() );
0325     if( systemTimezone() == true  )
0326     {
0327         QDateTime localTime = QDateTime::currentDateTime().toLocalTime();
0328         localTime.setTimeSpec( Qt::UTC );
0329         d->m_marbleWidget->model()->setClockTimezone( QDateTime::currentDateTime().toUTC().secsTo( localTime ) );
0330     }
0331     else if( UTC() == true )
0332     {
0333         d->m_marbleWidget->model()->setClockTimezone( 0 );
0334     }
0335     else if( customTimezone() == true )
0336     {
0337         d->m_marbleWidget->model()->setClockTimezone( d->m_timezone.value( chosenTimezone() ) );
0338     }
0339
0340     // Routing
0341
0342     // ownCloud
0343     d->ui_cloudSyncSettings.kcfg_enableSync->setChecked( syncEnabled() );
0344     d->ui_cloudSyncSettings.kcfg_syncBookmarks->setChecked( syncBookmarks() );
0345     d->ui_cloudSyncSettings.kcfg_syncRoutes->setChecked( syncRoutes() );
0346     d->ui_cloudSyncSettings.kcfg_owncloudServer->setText( owncloudServer() );
0347     d->ui_cloudSyncSettings.kcfg_owncloudUsername->setText( owncloudUsername() );
0348     d->ui_cloudSyncSettings.kcfg_owncloudPassword->setText( owncloudPassword() );
0349
0350     // Read the settings of the plugins
0351     d->m_marbleWidget->readPluginSettings( d->m_settings );
0352
0353     // The settings loaded in the config dialog have been changed.
0354     emit settingsChanged();
0355 }
0356
0357 void QtMarbleConfigDialog::updateCloudSyncStatus( const QString &status )
0358 {
0359     d->m_cloudSyncStatusLabel->setText(status);
0360     CloudSyncManager::Status status_type =
0361             d->m_cloudSyncManager ? d->m_cloudSyncManager->status() : CloudSyncManager::Unknown;
0362     switch (status_type) {
0363         case CloudSyncManager::Success:
0364             d->m_cloudSyncStatusLabel->setStyleSheet("QLabel { color : green; }");
0365             break;
0366         case CloudSyncManager::Error:
0367             d->m_cloudSyncStatusLabel->setStyleSheet("QLabel { color : red; }");
0368             break;
0369         case CloudSyncManager::Unknown:
0370             d->m_cloudSyncStatusLabel->setStyleSheet("QLabel { color : grey; }");
0371             break;
0372     }
0373 }
0374
0375 void QtMarbleConfigDialog::writeSettings()
0376 {
0377     syncSettings();
0378
0379     d->m_settings.beginGroup( "View" );
0380     d->m_settings.setValue( "distanceUnit", d->ui_viewSettings.kcfg_distanceUnit->currentIndex() );
0381     d->m_settings.setValue( "angleUnit", d->ui_viewSettings.kcfg_angleUnit->currentIndex() );
0382     d->m_settings.setValue( "stillQuality", d->ui_viewSettings.kcfg_stillQuality->currentIndex() );
0383     d->m_settings.setValue( "animationQuality", d->ui_viewSettings.kcfg_animationQuality->currentIndex() );
0384     d->m_settings.setValue( "mapFont", d->ui_viewSettings.kcfg_mapFont->currentFont() );
0385     d->m_settings.endGroup();
0386
0387     d->m_settings.beginGroup( "Navigation" );
0388     d->m_settings.setValue( "onStartup", d->ui_navigationSettings.kcfg_onStartup->currentIndex() );
0389     d->m_settings.setValue( "inertialEarthRotation", d->ui_navigationSettings.kcfg_inertialEarthRotation->isChecked() );
0390     d->m_settings.setValue( "mouseViewRotation", d->ui_navigationSettings.kcfg_mouseViewRotation->isChecked() );
0391     d->m_settings.setValue( "animateTargetVoyage", d->ui_navigationSettings.kcfg_animateTargetVoyage->isChecked() );
0392     if( d->ui_navigationSettings.kcfg_externalMapEditor->currentIndex() == 0 ) {
0393         d->m_settings.setValue( "externalMapEditor", "" );
0394     } else if( d->ui_navigationSettings.kcfg_externalMapEditor->currentIndex() == 1 ) {
0395         d->m_settings.setValue( "externalMapEditor", "potlatch" );
0396     } else if( d->ui_navigationSettings.kcfg_externalMapEditor->currentIndex() == 2 ) {
0397         d->m_settings.setValue( "externalMapEditor", "josm" );
0398     } else if( d->ui_navigationSettings.kcfg_externalMapEditor->currentIndex() == 3 ) {
0399         d->m_settings.setValue( "externalMapEditor", "merkaartor" );
0400     } else {
0401         Q_ASSERT( false && "Unexpected index of the external editor setting" );
0402     }
0403     d->m_settings.endGroup();
0404
0405     d->m_settings.beginGroup( "Cache" );
0406     d->m_settings.setValue( "volatileTileCacheLimit", d->ui_cacheSettings.kcfg_volatileTileCacheLimit->value() );
0407     d->m_settings.setValue( "persistentTileCacheLimit", d->ui_cacheSettings.kcfg_persistentTileCacheLimit->value() );
0408     d->m_settings.setValue( "proxyUrl", d->ui_cacheSettings.kcfg_proxyUrl->text() );
0409     d->m_settings.setValue( "proxyPort", d->ui_cacheSettings.kcfg_proxyPort->value() );
0410     d->m_settings.setValue( "proxyType", d->ui_cacheSettings.kcfg_proxyType->currentIndex() );
0411     if ( d->ui_cacheSettings.kcfg_proxyAuth->isChecked() ) {
0412         d->m_settings.setValue( "proxyAuth", true );
0413         d->m_settings.setValue( "proxyUser", d->ui_cacheSettings.kcfg_proxyUser->text() );
0414         d->m_settings.setValue( "proxyPass", d->ui_cacheSettings.kcfg_proxyPass->text() );
0415     } else {
0416         d->m_settings.setValue( "proxyAuth", false );
0417     }
0418     d->m_settings.endGroup();
0419
0420     d->m_settings.beginGroup( "Time" );
0421     d->m_settings.setValue( "systemTimezone", d->ui_timeSettings.kcfg_systemTimezone->isChecked() );
0422     d->m_settings.setValue( "UTC", d->ui_timeSettings.kcfg_utc->isChecked() );
0423     d->m_settings.setValue( "customTimezone", d->ui_timeSettings.kcfg_customTimezone->isChecked() );
0424     d->m_settings.setValue( "systemTime", d->ui_timeSettings.kcfg_systemTime->isChecked() );
0425     d->m_settings.setValue( "lastSessionTime", d->ui_timeSettings.kcfg_lastSessionTime->isChecked() );
0426     d->m_settings.setValue( "chosenTimezone", d->ui_timeSettings.kcfg_chosenTimezone->currentIndex() );
0427     d->m_settings.endGroup();
0428
0429     d->m_settings.beginGroup( "CloudSync" );
0430     d->m_settings.setValue( "enableSync", d->ui_cloudSyncSettings.kcfg_enableSync->isChecked() );
0431     d->m_settings.setValue( "syncBackend", "owncloud" );
0432     d->m_settings.setValue( "syncBookmarks", d->ui_cloudSyncSettings.kcfg_syncBookmarks->isChecked() );
0433     d->m_settings.setValue( "syncRoutes", d->ui_cloudSyncSettings.kcfg_syncRoutes->isChecked() );
0434     d->m_settings.setValue( "owncloudServer", d->ui_cloudSyncSettings.kcfg_owncloudServer->text() );
0435     d->m_settings.setValue( "owncloudUsername", d->ui_cloudSyncSettings.kcfg_owncloudUsername->text() );
0436     d->m_settings.setValue( "owncloudPassword", d->ui_cloudSyncSettings.kcfg_owncloudPassword->text() );
0437     d->m_settings.endGroup();
0438
0439     // Plugins
0440     d->m_marbleWidget->writePluginSettings( d->m_settings );
0441
0442     emit settingsChanged();
0443 }
0444
0445 MarbleLocale::MeasurementSystem QtMarbleConfigDialog::measurementSystem() const
0446 {
0447     if( d->m_settings.contains( "View/distanceUnit" ) ) {
0448         return (MarbleLocale::MeasurementSystem)d->m_settings.value( "View/distanceUnit" ).toInt();
0449     }
0450
0451     MarbleLocale *locale = MarbleGlobal::getInstance()->locale();
0452     return locale->measurementSystem();
0453 }
0454
0455 Marble::AngleUnit QtMarbleConfigDialog::angleUnit() const
0456 {
0457     return (Marble::AngleUnit) d->m_settings.value( "View/angleUnit", Marble::DMSDegree ).toInt();
0458 }
0459
0460 void QtMarbleConfigDialog::setAngleUnit(Marble::AngleUnit unit)
0461 {
0462     d->m_settings.setValue( "View/angleUnit", (int)unit );
0463     d->ui_viewSettings.kcfg_angleUnit->setCurrentIndex( angleUnit() );
0464     emit settingsChanged();
0465 }
0466
0467 Marble::MapQuality QtMarbleConfigDialog::stillQuality() const
0468 {
0469     return (Marble::MapQuality) d->m_settings.value( "View/stillQuality",
0470                                 Marble::HighQuality ).toInt();
0471 }
0472
0473 Marble::MapQuality QtMarbleConfigDialog::animationQuality() const
0474 {
0475     return (Marble::MapQuality) d->m_settings.value( "View/animationQuality",
0476                                 Marble::LowQuality ).toInt();
0477 }
0478
0479 QFont QtMarbleConfigDialog::mapFont() const
0480 {
0481     return d->m_settings.value( "View/mapFont", QApplication::font() ).value<QFont>();
0482 }
0483
0484 int QtMarbleConfigDialog::onStartup() const
0485 {
0486     bool smallScreen = MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen;
0487     int defaultValue = smallScreen ? Marble::LastLocationVisited : Marble::ShowHomeLocation;
0488     return d->m_settings.value( "Navigation/onStartup", defaultValue ).toInt();
0489 }
0490
0491 QString QtMarbleConfigDialog::externalMapEditor() const
0492 {
0493     return d->m_settings.value( "Navigation/externalMapEditor", "" ).toString();
0494 }
0495
0496 bool QtMarbleConfigDialog::animateTargetVoyage() const
0497 {
0498     const bool smallScreen = MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen;
0499     return d->m_settings.value( "Navigation/animateTargetVoyage", smallScreen ).toBool();
0500 }
0501
0502 bool QtMarbleConfigDialog::inertialEarthRotation() const
0503 {
0504     return d->m_settings.value( "Navigation/inertialEarthRotation", true ).toBool();
0505 }
0506
0507 bool QtMarbleConfigDialog::mouseViewRotation() const
0508 {
0509     return d->m_settings.value( "Navigation/mouseViewRotation", true ).toBool();
0510 }
0511
0512 int QtMarbleConfigDialog::volatileTileCacheLimit() const
0513 {
0514     int defaultValue = (MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen) ? 6 : 100;
0515     return d->m_settings.value( "Cache/volatileTileCacheLimit", defaultValue ).toInt();
0516 }
0517
0518 int QtMarbleConfigDialog::persistentTileCacheLimit() const
0519 {
0520     return d->m_settings.value( "Cache/persistentTileCacheLimit", 0 ).toInt(); // default to unlimited
0521 }
0522
0523 QString QtMarbleConfigDialog::proxyUrl() const
0524 {
0525     return d->m_settings.value( "Cache/proxyUrl", "" ).toString();
0526 }
0527
0528 int QtMarbleConfigDialog::proxyPort() const
0529 {
0530     return d->m_settings.value( "Cache/proxyPort", 8080 ).toInt();
0531 }
0532
0533 QString QtMarbleConfigDialog::proxyUser() const
0534 {
0535     return d->m_settings.value( "Cache/proxyUser", "" ).toString();
0536 }
0537
0538 QString QtMarbleConfigDialog::proxyPass() const
0539 {
0540     return d->m_settings.value( "Cache/proxyPass", "" ).toString();
0541 }
0542
0543 bool QtMarbleConfigDialog::proxyType() const
0544 {
0545     return d->m_settings.value( "Cache/proxyType", Marble::HttpProxy ).toInt();
0546 }
0547
0548 bool QtMarbleConfigDialog::proxyAuth() const
0549 {
0550     return d->m_settings.value( "Cache/proxyAuth", false ).toBool();
0551 }
0552
0553 bool QtMarbleConfigDialog::systemTimezone() const
0554 {
0555     return d->m_settings.value( "Time/systemTimezone", true ).toBool();
0556 }
0557
0558 bool QtMarbleConfigDialog::customTimezone() const
0559 {
0560     return d->m_settings.value( "Time/customTimezone", false ).toBool();
0561 }
0562
0563 bool QtMarbleConfigDialog::UTC() const
0564 {
0565     return d->m_settings.value( "Time/UTC", false ).toBool();
0566 }
0567
0568 bool QtMarbleConfigDialog::systemTime() const
0569 {
0570     return d->m_settings.value( "Time/systemTime", true ).toBool();
0571 }
0572
0573 bool QtMarbleConfigDialog::lastSessionTime() const
0574 {
0575     return d->m_settings.value( "Time/lastSessionTime", false ).toBool();
0576 }
0577
0578 int QtMarbleConfigDialog::chosenTimezone() const
0579 {
0580     return d->m_settings.value( "Time/chosenTimezone", 0 ).toInt();
0581 }
0582
0583 void QtMarbleConfigDialog::initializeCustomTimezone()
0584 {
0585     if( d->m_timezone.count() == 0)
0586     {
0587         d->m_timezone.insert( 0, 0 );
0588         d->m_timezone.insert( 1, 3600 );
0589         d->m_timezone.insert( 2, 7200 );
0590         d->m_timezone.insert( 3, 7200 );
0591         d->m_timezone.insert( 4, 10800 );
0592         d->m_timezone.insert( 5, 12600 );
0593         d->m_timezone.insert( 6, 14400 );
0594         d->m_timezone.insert( 7, 18000 );
0595         d->m_timezone.insert( 8, 19800 );
0596         d->m_timezone.insert( 9, 21600 );
0597         d->m_timezone.insert( 10, 25200 );
0598         d->m_timezone.insert( 11, 28800 );
0599         d->m_timezone.insert( 12, 32400 );
0600         d->m_timezone.insert( 13, 34200 );
0601         d->m_timezone.insert( 14, 36000 );
0602         d->m_timezone.insert( 15, 39600 );
0603         d->m_timezone.insert( 16, 43200 );
0604         d->m_timezone.insert( 17, -39600 );
0605         d->m_timezone.insert( 18, -36000 );
0606         d->m_timezone.insert( 19, -32400 );
0607         d->m_timezone.insert( 20, -28800 );
0608         d->m_timezone.insert( 21, -25200 );
0609         d->m_timezone.insert( 22, -25200 );
0610         d->m_timezone.insert( 23, -21600 );
0611         d->m_timezone.insert( 24, -18000 );
0612         d->m_timezone.insert( 25, -18000 );
0613         d->m_timezone.insert( 26, -14400 );
0614         d->m_timezone.insert( 27, -12600 );
0615         d->m_timezone.insert( 28, -10800 );
0616         d->m_timezone.insert( 29, -10800 );
0617         d->m_timezone.insert( 30, -3600 );
0618     }
0619 }
0620
0621 bool QtMarbleConfigDialog::syncEnabled() const
0622 {
0623     return d->m_settings.value( "CloudSync/enableSync", false ).toBool();
0624 }
0625
0626 QString QtMarbleConfigDialog::syncBackend() const
0627 {
0628     return d->m_settings.value( "CloudSync/syncBackend", "" ).toString();
0629 }
0630
0631 bool QtMarbleConfigDialog::syncBookmarks() const
0632 {
0633     return d->m_settings.value( "CloudSync/syncBookmarks", true ).toBool();
0634 }
0635
0636 bool QtMarbleConfigDialog::syncRoutes() const
0637 {
0638     return d->m_settings.value( "CloudSync/syncRoutes", true ).toBool();
0639 }
0640
0641 QString QtMarbleConfigDialog::owncloudServer() const
0642 {
0643     return d->m_settings.value( "CloudSync/owncloudServer", "" ).toString();
0644 }
0645
0646 QString QtMarbleConfigDialog::owncloudUsername() const
0647 {
0648     return d->m_settings.value( "CloudSync/owncloudUsername", "" ).toString();
0649 }
0650
0651 QString QtMarbleConfigDialog::owncloudPassword() const
0652 {
0653     return d->m_settings.value( "CloudSync/owncloudPassword", "" ).toString();
0654 }
0655
0656 }
0657
0658 #include "moc_QtMarbleConfigDialog.cpp"