diff --git a/MainWindow/Window.cpp b/MainWindow/Window.cpp
index 99a62e90..4d001808 100644
--- a/MainWindow/Window.cpp
+++ b/MainWindow/Window.cpp
@@ -1,1998 +1,2006 @@
 /* Copyright (C) 2003-2020 The KPhotoAlbum Development Team
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "Window.h"
 
 #include <config-kpa-kipi.h>
 #include <stdexcept>
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 
 #include <KActionCollection>
 #include <KActionMenu>
+#include <KColorSchemeManager>
 #include <KConfigGroup>
 #include <KEditToolBar>
 #include <KIconLoader>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KPasswordDialog>
 #include <KProcess>
 #include <KSharedConfig>
 #include <KShortcutsDialog>
 #include <KStandardAction>
 #include <KToggleAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QCloseEvent>
 #include <QContextMenuEvent>
 #include <QCursor>
 #include <QDesktopServices>
 #include <QDir>
 #include <QElapsedTimer>
 #include <QFrame>
 #include <QInputDialog>
 #include <QLayout>
 #include <QLoggingCategory>
 #include <QMenu>
 #include <QMessageBox>
 #include <QMimeData>
 #include <QMoveEvent>
 #include <QObject>
 #include <QResizeEvent>
 #include <QStackedWidget>
 #include <QTimer>
 #include <QVBoxLayout>
 #include <kio_version.h> // for #if KIO_VERSION...
 #include <ktip.h>
 
 #ifdef HASKIPI
 #include <KIPI/Plugin>
 #include <KIPI/PluginLoader>
 #endif
 
 #include <AnnotationDialog/Dialog.h>
 #include <BackgroundJobs/SearchForVideosWithoutLengthInfo.h>
 #include <BackgroundJobs/SearchForVideosWithoutVideoThumbnailsJob.h>
 #include <BackgroundTaskManager/JobManager.h>
 #include <Browser/BrowserWidget.h>
 #include <DB/CategoryCollection.h>
 #include <DB/ImageDB.h>
 #include <DB/ImageDateCollection.h>
 #include <DB/ImageInfo.h>
 #include <DB/MD5.h>
 #include <DB/MD5Map.h>
 #include <DB/UIDelegate.h>
 #include <DateBar/DateBarWidget.h>
 #include <Exif/Database.h>
 #include <Exif/Info.h>
 #include <Exif/InfoDialog.h>
 #include <Exif/ReReadDialog.h>
 #include <HTMLGenerator/HTMLDialog.h>
 #include <ImageManager/AsyncLoader.h>
 #include <ImageManager/ThumbnailBuilder.h>
 #include <ImageManager/ThumbnailCache.h>
 #include <ImportExport/Export.h>
 #include <ImportExport/Import.h>
 #ifdef HASKIPI
 #include <Plugins/Interface.h>
 #endif
 #ifdef KF5Purpose_FOUND
 #include <Plugins/PurposeMenu.h>
 #endif
 #include "AutoStackImages.h"
 #include "BreadcrumbViewer.h"
 #include "CopyPopup.h"
 #include "DeleteDialog.h"
 #include "DirtyIndicator.h"
 #include "DuplicateMerger/DuplicateMerger.h"
 #include "ExternalPopup.h"
 #include "FeatureDialog.h"
 #include "ImageCounter.h"
 #include "InvalidDateFinder.h"
 #include "Logging.h"
 #include "Options.h"
 #include "SearchBar.h"
 #include "SplashScreen.h"
 #include "StatisticsDialog.h"
 #include "StatusBar.h"
 #include "TokenEditor.h"
 #include "UpdateVideoThumbnail.h"
 #include "WelcomeDialog.h"
 
 #ifdef HAVE_MARBLE
 #include <Map/MapView.h>
 #endif
 #ifdef KPA_ENABLE_REMOTECONTROL
 #include <RemoteControl/RemoteInterface.h>
 #endif
 #include <Settings/SettingsData.h>
 #include <Settings/SettingsDialog.h>
 #include <ThumbnailView/FilterWidget.h>
 #include <ThumbnailView/ThumbnailFacade.h>
 #include <ThumbnailView/enums.h>
 #include <Utilities/DemoUtil.h>
 #include <Utilities/FileNameUtil.h>
 #include <Utilities/List.h>
 #include <Utilities/ShowBusyCursor.h>
 #include <Utilities/VideoUtil.h>
 #include <Viewer/ViewerWidget.h>
 
 using namespace DB;
 
 MainWindow::Window *MainWindow::Window::s_instance = nullptr;
 
 MainWindow::Window::Window(QWidget *parent)
     : KXmlGuiWindow(parent)
     , m_annotationDialog(nullptr)
     , m_deleteDialog(nullptr)
     , m_htmlDialog(nullptr)
     , m_tokenEditor(nullptr)
 #ifdef HAVE_MARBLE
     , m_positionBrowser(nullptr)
 #endif
 {
     qCDebug(MainWindowLog) << "Using icon theme: " << QIcon::themeName();
     qCDebug(MainWindowLog) << "Icon search paths: " << QIcon::themeSearchPaths();
     QElapsedTimer timer;
     timer.start();
     SplashScreen::instance()->message(i18n("Loading Database"));
     s_instance = this;
 
     bool gotConfigFile = load();
     if (!gotConfigFile)
         throw 0;
     qCInfo(TimingLog) << "MainWindow: Loading Database: " << timer.restart() << "ms.";
     SplashScreen::instance()->message(i18n("Loading Main Window"));
 
     QWidget *top = new QWidget(this);
     QVBoxLayout *lay = new QVBoxLayout(top);
     lay->setSpacing(2);
     lay->setContentsMargins(2, 2, 2, 2);
     setCentralWidget(top);
 
     m_stack = new QStackedWidget(top);
     lay->addWidget(m_stack, 1);
 
     m_dateBar = new DateBar::DateBarWidget(top);
     lay->addWidget(m_dateBar);
 
     m_dateBarLine = new QFrame(top);
     m_dateBarLine->setFrameStyle(QFrame::HLine | QFrame::Plain);
     m_dateBarLine->setLineWidth(0);
     m_dateBarLine->setMidLineWidth(0);
 
     QPalette pal = m_dateBarLine->palette();
     pal.setColor(QPalette::WindowText, palette().window().color());
     m_dateBarLine->setPalette(pal);
 
     lay->addWidget(m_dateBarLine);
 
     setHistogramVisibilty(Settings::SettingsData::instance()->showHistogram());
 
     m_browser = new Browser::BrowserWidget(m_stack);
     m_thumbnailView = new ThumbnailView::ThumbnailFacade();
 
     m_stack->addWidget(m_browser);
     m_stack->addWidget(m_thumbnailView->gui());
     m_stack->setCurrentWidget(m_browser);
 
     m_settingsDialog = nullptr;
     qCInfo(TimingLog) << "MainWindow: Loading MainWindow: " << timer.restart() << "ms.";
     setupMenuBar();
     qCInfo(TimingLog) << "MainWindow: setupMenuBar: " << timer.restart() << "ms.";
     createSearchBar();
     qCInfo(TimingLog) << "MainWindow: createSearchBar: " << timer.restart() << "ms.";
     setupStatusBar();
     qCInfo(TimingLog) << "MainWindow: setupStatusBar: " << timer.restart() << "ms.";
 
     // Misc
     m_autoSaveTimer = new QTimer(this);
     connect(m_autoSaveTimer, &QTimer::timeout, this, &Window::slotAutoSave);
     startAutoSaveTimer();
 
     connect(m_browser, &Browser::BrowserWidget::showingOverview,
             this, &Window::showBrowser);
     connect(m_browser, &Browser::BrowserWidget::pathChanged,
             m_statusBar->mp_pathIndicator, &BreadcrumbViewer::setBreadcrumbs);
     connect(m_statusBar->mp_pathIndicator, &BreadcrumbViewer::widenToBreadcrumb,
             m_browser, &Browser::BrowserWidget::widenToBreadcrumb);
     connect(m_browser, &Browser::BrowserWidget::pathChanged,
             this, QOverload<const Browser::BreadcrumbList &>::of(&Window::updateDateBar));
 
     connect(m_dateBar, &DateBar::DateBarWidget::dateSelected,
             m_thumbnailView, &ThumbnailView::ThumbnailFacade::gotoDate);
     connect(m_dateBar, &DateBar::DateBarWidget::toolTipInfo, this, &Window::showDateBarTip);
     connect(Settings::SettingsData::instance(), &Settings::SettingsData::histogramSizeChanged,
             m_dateBar, &DateBar::DateBarWidget::setHistogramBarSize);
     connect(Settings::SettingsData::instance(), &Settings::SettingsData::actualThumbnailSizeChanged,
             this, &Window::slotThumbnailSizeChanged);
 
     connect(m_dateBar, &DateBar::DateBarWidget::dateRangeChange, this, &Window::setDateRange);
     connect(m_dateBar, &DateBar::DateBarWidget::dateRangeCleared, this, &Window::clearDateRange);
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::currentDateChanged,
             m_dateBar, &DateBar::DateBarWidget::setDate);
 
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::showImage, this, &Window::showImage);
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::showSelection, this, QOverload<>::of(&Window::slotView));
 
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::fileIdUnderCursorChanged, this, &Window::slotSetFileName);
     connect(DB::ImageDB::instance(), &DB::ImageDB::totalChanged, this, QOverload<>::of(&Window::updateDateBar));
     connect(DB::ImageDB::instance()->categoryCollection(), &DB::CategoryCollection::categoryCollectionChanged,
             this, &Window::slotOptionGroupChanged);
     connect(m_browser, &Browser::BrowserWidget::imageCount, m_statusBar->mp_partial, &ImageCounter::showBrowserMatches);
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::selectionChanged, this, &Window::updateContextMenuFromSelectionSize);
 
     checkIfVideoThumbnailerIsInstalled();
     executeStartupActions();
 
     qCInfo(TimingLog) << "MainWindow: executeStartupActions " << timer.restart() << "ms.";
     QTimer::singleShot(0, this, SLOT(delayedInit()));
     updateContextMenuFromSelectionSize(0);
 
     // Automatically save toolbar settings
     setAutoSaveSettings();
 
     qCInfo(TimingLog) << "MainWindow: misc setup time: " << timer.restart() << "ms.";
 }
 
 MainWindow::Window::~Window()
 {
     DB::ImageDB::deleteInstance();
     ImageManager::ThumbnailCache::deleteInstance();
     Exif::Database::deleteInstance();
 }
 
 void MainWindow::Window::delayedInit()
 {
     QElapsedTimer timer;
     timer.start();
     SplashScreen *splash = SplashScreen::instance();
     setupPluginMenu();
     qCInfo(TimingLog) << "MainWindow: setupPluginMenu: " << timer.restart() << "ms.";
 
     if (Settings::SettingsData::instance()->searchForImagesOnStart() || Options::the()->searchForImagesOnStart()) {
         splash->message(i18n("Searching for New Files"));
         qApp->processEvents();
         DB::ImageDB::instance()->slotRescan();
         qCInfo(TimingLog) << "MainWindow: Search for New Files: " << timer.restart() << "ms.";
     }
 
     if (!Settings::SettingsData::instance()->delayLoadingPlugins()) {
         splash->message(i18n("Loading Plug-ins"));
         loadKipiPlugins();
         qCInfo(TimingLog) << "MainWindow: Loading Plug-ins: " << timer.restart() << "ms.";
     }
 
     splash->done();
     show();
     updateDateBar();
     qCInfo(TimingLog) << "MainWindow: MainWindow.show():" << timer.restart() << "ms.";
 
     QUrl importUrl = Options::the()->importFile();
     if (importUrl.isValid()) {
         // I need to do this in delayed init to get the import window on top of the normal window
         ImportExport::Import::imageImport(importUrl);
         qCInfo(TimingLog) << "MainWindow: imageImport:" << timer.restart() << "ms.";
     } else {
         // I need to postpone this otherwise the tip dialog will not get focus on start up
         KTipDialog::showTip(this);
     }
 
     Exif::Database::instance(); // Load the database
     qCInfo(TimingLog) << "MainWindow: Loading Exif DB:" << timer.restart() << "ms.";
 
 #ifdef KPA_ENABLE_REMOTECONTROL
     if (!Options::the()->listen().isNull())
         RemoteControl::RemoteInterface::instance().listen(Options::the()->listen());
     else if (Settings::SettingsData::instance()->listenForAndroidDevicesOnStartup())
         RemoteControl::RemoteInterface::instance().listen();
 #endif
 }
 
 bool MainWindow::Window::slotExit()
 {
     if (Options::the()->demoMode()) {
         QString txt = i18n("<p><b>Delete Your Temporary Demo Database</b></p>"
                            "<p>I hope you enjoyed the KPhotoAlbum demo. The demo database was copied to "
                            "/tmp, should it be deleted now? If you do not delete it, it will waste disk space; "
                            "on the other hand, if you want to come back and try the demo again, you "
                            "might want to keep it around with the changes you made through this session.</p>");
         int ret = KMessageBox::questionYesNoCancel(this, txt, i18n("Delete Demo Database"),
                                                    KStandardGuiItem::yes(), KStandardGuiItem::no(), KStandardGuiItem::cancel(),
                                                    QString::fromLatin1("deleteDemoDatabase"));
         if (ret == KMessageBox::Cancel)
             return false;
         else if (ret == KMessageBox::Yes) {
             Utilities::deleteDemo();
             goto doQuit;
         } else {
             // pass through to the check for dirtyness.
         }
     }
 
     if (m_statusBar->mp_dirtyIndicator->isSaveDirty()) {
         int ret = KMessageBox::warningYesNoCancel(this, i18n("Do you want to save the changes?"),
                                                   i18n("Save Changes?"));
         if (ret == KMessageBox::Cancel) {
             return false;
         }
         if (ret == KMessageBox::Yes) {
             slotSave();
         }
         if (ret == KMessageBox::No) {
             QDir().remove(Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1(".#index.xml"));
         }
     }
     // Flush any remaining thumbnails
     ImageManager::ThumbnailCache::instance()->save();
 
 doQuit:
     ImageManager::AsyncLoader::instance()->requestExit();
     qApp->quit();
     return true;
 }
 
 void MainWindow::Window::slotOptions()
 {
     if (!m_settingsDialog) {
         m_settingsDialog = new Settings::SettingsDialog(this);
         // lambda expression because because reloadThumbnails has default parameters:
         connect(m_settingsDialog, &Settings::SettingsDialog::changed, this, [=]() { this->reloadThumbnails(); });
         connect(m_settingsDialog, &Settings::SettingsDialog::changed, this, &Window::startAutoSaveTimer);
         connect(m_settingsDialog, &Settings::SettingsDialog::changed, m_browser, &Browser::BrowserWidget::reload);
     }
     m_settingsDialog->show();
 }
 
 void MainWindow::Window::slotCreateImageStack()
 {
     const DB::FileNameList list = selected();
     if (list.size() < 2) {
         // it doesn't make sense to make a stack from one image, does it?
         return;
     }
 
     bool ok = DB::ImageDB::instance()->stack(list);
     if (!ok) {
         if (KMessageBox::questionYesNo(this,
                                        i18n("Some of the selected images already belong to a stack. "
                                             "Do you want to remove them from their stacks and create a "
                                             "completely new one?"),
                                        i18n("Stacking Error"))
             == KMessageBox::Yes) {
             DB::ImageDB::instance()->unstack(list);
             if (!DB::ImageDB::instance()->stack(list)) {
                 KMessageBox::sorry(this,
                                    i18n("Unknown error, stack creation failed."),
                                    i18n("Stacking Error"));
                 return;
             }
         } else {
             return;
         }
     }
 
     DirtyIndicator::markDirty();
     // The current item might have just became invisible
     m_thumbnailView->setCurrentItem(list.at(0));
     m_thumbnailView->updateDisplayModel();
 }
 
 /** @short Make the selected image the head of a stack
  *
  * The whole point of image stacking is to group images together and then select
  * one of them as the "most important". This function is (maybe just a
  * temporary) way of promoting a selected image to the "head" of a stack it
  * belongs to. In future, it might get replaced by a Ligtroom-like interface.
  * */
 void MainWindow::Window::slotSetStackHead()
 {
     const DB::FileNameList list = selected();
     if (list.size() != 1) {
         // this should be checked by enabling/disabling of QActions
         return;
     }
 
     setStackHead(*list.begin());
 }
 
 void MainWindow::Window::setStackHead(const DB::FileName &image)
 {
     if (!image.info()->isStacked())
         return;
 
     unsigned int oldOrder = image.info()->stackOrder();
 
     const DB::FileNameList others = DB::ImageDB::instance()->getStackFor(image);
     for (const DB::FileName &current : others) {
         if (current == image) {
             current.info()->setStackOrder(1);
         } else if (current.info()->stackOrder() < oldOrder) {
             current.info()->setStackOrder(current.info()->stackOrder() + 1);
         }
     }
 
     DirtyIndicator::markDirty();
     m_thumbnailView->updateDisplayModel();
 }
 
 void MainWindow::Window::slotUnStackImages()
 {
     const DB::FileNameList &list = selected();
     if (list.isEmpty())
         return;
 
     DB::ImageDB::instance()->unstack(list);
     DirtyIndicator::markDirty();
     m_thumbnailView->updateDisplayModel();
 }
 
 void MainWindow::Window::slotConfigureAllImages()
 {
     configureImages(false);
 }
 
 void MainWindow::Window::slotConfigureImagesOneAtATime()
 {
     configureImages(true);
 }
 
 void MainWindow::Window::configureImages(bool oneAtATime)
 {
     const DB::FileNameList &list = selected();
     if (list.isEmpty()) {
         KMessageBox::sorry(this, i18n("No item is selected."), i18n("No Selection"));
     } else {
         DB::ImageInfoList images;
         for (const DB::FileName &fileName : list) {
             images.append(fileName.info());
         }
         configureImages(images, oneAtATime);
     }
 }
 
 void MainWindow::Window::configureImages(const DB::ImageInfoList &list, bool oneAtATime)
 {
     s_instance->configImages(list, oneAtATime);
 }
 
 void MainWindow::Window::configImages(const DB::ImageInfoList &list, bool oneAtATime)
 {
     createAnnotationDialog();
     if (m_annotationDialog->configure(list, oneAtATime) == QDialog::Rejected)
         return;
 
     reloadThumbnails(ThumbnailView::MaintainSelection);
 }
 
 void MainWindow::Window::slotSearch()
 {
     createAnnotationDialog();
     DB::ImageSearchInfo searchInfo = m_annotationDialog->search();
     if (!searchInfo.isNull())
         m_browser->addSearch(searchInfo);
 }
 
 void MainWindow::Window::createAnnotationDialog()
 {
     Utilities::ShowBusyCursor dummy;
     if (!m_annotationDialog.isNull())
         return;
 
     m_annotationDialog = new AnnotationDialog::Dialog(nullptr);
     connect(m_annotationDialog.data(), &AnnotationDialog::Dialog::imageRotated, this, &Window::slotImageRotated);
 }
 
 void MainWindow::Window::slotSave()
 {
     Utilities::ShowBusyCursor dummy;
     m_statusBar->showMessage(i18n("Saving..."), 5000);
     DB::ImageDB::instance()->save(Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1("index.xml"), false);
     ImageManager::ThumbnailCache::instance()->save();
     m_statusBar->mp_dirtyIndicator->saved();
     QDir().remove(Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1(".#index.xml"));
     m_statusBar->showMessage(i18n("Saving... Done"), 5000);
 }
 
 void MainWindow::Window::slotDeleteSelected()
 {
     if (!m_deleteDialog)
         m_deleteDialog = new DeleteDialog(this);
     if (m_deleteDialog->exec(selected()) != QDialog::Accepted)
         return;
 
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotCopySelectedURLs()
 {
     QList<QUrl> urls;
     int urlcount = 0;
     const auto selectedFiles = selected();
     for (const DB::FileName &fileName : selectedFiles) {
         urls.append(QUrl::fromLocalFile(fileName.absolute()));
         urlcount++;
     }
     if (urlcount == 1)
         m_paste->setEnabled(true);
     else
         m_paste->setEnabled(false);
     QMimeData *mimeData = new QMimeData;
     mimeData->setUrls(urls);
 
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void MainWindow::Window::slotPasteInformation()
 {
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
 
     // Idealy this would look like
     // QList<QUrl> urls;
     // urls.fromMimeData(mimeData);
     // if ( urls.count() != 1 ) return;
     // const QString string = urls.first().path();
 
     QString string = mimeData->text();
     // fail silent if more than one image is in clipboard.
     if (string.count(QString::fromLatin1("\n")) != 0)
         return;
 
     const QString urlHead = QLatin1String("file://");
     if (string.startsWith(urlHead)) {
         string = string.right(string.size() - urlHead.size());
     }
 
     const DB::FileName fileName = DB::FileName::fromAbsolutePath(string);
     // fail silent if there is no file.
     if (fileName.isNull())
         return;
 
     MD5 originalSum = MD5Sum(fileName);
     ImageInfoPtr originalInfo;
     if (DB::ImageDB::instance()->md5Map()->contains(originalSum)) {
         originalInfo = DB::ImageDB::instance()->info(fileName);
     } else {
         originalInfo = fileName.info();
     }
     // fail silent if there is no info for the file.
     if (!originalInfo)
         return;
 
     const auto selectedFiles = selected();
     for (const DB::FileName &newFile : selectedFiles) {
         newFile.info()->copyExtraData(*originalInfo, false);
     }
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotReReadExifInfo()
 {
     DB::FileNameList files = selectedOnDisk();
     static Exif::ReReadDialog *dialog = nullptr;
     if (!dialog)
         dialog = new Exif::ReReadDialog(this);
     if (dialog->exec(files) == QDialog::Accepted)
         DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotAutoStackImages()
 {
     const DB::FileNameList list = selected();
     if (list.isEmpty()) {
         KMessageBox::sorry(this, i18n("No item is selected."), i18n("No Selection"));
         return;
     }
     QPointer<MainWindow::AutoStackImages> stacker = new AutoStackImages(this, list);
     if (stacker->exec() == QDialog::Accepted)
         showThumbNails();
     delete stacker;
 }
 
 /**
  * In thumbnail mode, return a list of files that are selected.
  * Otherwise, return all images in the current scope/context.
  */
 DB::FileNameList MainWindow::Window::selected(ThumbnailView::SelectionMode mode) const
 {
     if (m_thumbnailView->gui() == m_stack->currentWidget())
         return m_thumbnailView->selection(mode);
     else
         // return all images in the current scope (parameter false: include images not on disk)
         return DB::ImageDB::instance()->currentScope(false);
 }
 
 void MainWindow::Window::slotViewNewWindow()
 {
     slotView(false, false);
 }
 
 /*
  * Returns a list of files that are both selected and on disk. If there are no
  * selected files, returns all files form current context that are on disk.
  * Note: On some setups (NFS), this can be a very time-consuming method!
  * */
 DB::FileNameList MainWindow::Window::selectedOnDisk()
 {
     const DB::FileNameList list = selected(ThumbnailView::NoExpandCollapsedStacks);
 
     DB::FileNameList listOnDisk;
     for (const DB::FileName &fileName : list) {
         if (DB::ImageInfo::imageOnDisk(fileName))
             listOnDisk.append(fileName);
     }
 
     return listOnDisk;
 }
 
 void MainWindow::Window::slotView(bool reuse, bool slideShow, bool random)
 {
     launchViewer(selected(ThumbnailView::NoExpandCollapsedStacks), reuse, slideShow, random);
 }
 
 void MainWindow::Window::slotView()
 {
     slotView(true, false, false);
 }
 
 void MainWindow::Window::launchViewer(const DB::FileNameList &inputMediaList, bool reuse, bool slideShow, bool random)
 {
     DB::FileNameList mediaList = inputMediaList;
     int seek = -1;
     if (mediaList.isEmpty()) {
         mediaList = m_thumbnailView->imageList(ThumbnailView::ViewOrder);
     } else if (mediaList.size() == 1) {
         // we fake it so it appears the user has selected all images
         // and magically scrolls to the originally selected one
         const DB::FileName first = mediaList.at(0);
         mediaList = m_thumbnailView->imageList(ThumbnailView::ViewOrder);
         seek = mediaList.indexOf(first);
     }
 
     if (mediaList.isEmpty())
         mediaList = DB::ImageDB::instance()->currentScope(false);
 
     if (mediaList.isEmpty()) {
         KMessageBox::sorry(this, i18n("There are no images to be shown."));
         return;
     }
 
     if (random) {
         mediaList = DB::FileNameList(Utilities::shuffleList(mediaList));
     }
 
     Viewer::ViewerWidget *viewer;
     if (reuse && Viewer::ViewerWidget::latest()) {
         viewer = Viewer::ViewerWidget::latest();
         viewer->raise();
         viewer->activateWindow();
     } else
         viewer = new Viewer::ViewerWidget(Viewer::ViewerWidget::ViewerWindow,
                                           &m_viewerInputMacros);
     connect(viewer, &Viewer::ViewerWidget::soughtTo, m_thumbnailView, &ThumbnailView::ThumbnailFacade::changeSingleSelection);
     connect(viewer, &Viewer::ViewerWidget::imageRotated, this, &Window::slotImageRotated);
 
     viewer->show(slideShow);
     viewer->load(mediaList, seek < 0 ? 0 : seek);
     viewer->raise();
 }
 
 void MainWindow::Window::slotSortByDateAndTime()
 {
     DB::ImageDB::instance()->sortAndMergeBackIn(selected());
     showThumbNails(DB::ImageDB::instance()->search(Browser::BrowserWidget::instance()->currentContext()));
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::slotSortAllByDateAndTime()
 {
     DB::ImageDB::instance()->sortAndMergeBackIn(DB::ImageDB::instance()->images());
     if (m_thumbnailView->gui() == m_stack->currentWidget())
         showThumbNails(DB::ImageDB::instance()->search(Browser::BrowserWidget::instance()->currentContext()));
     DirtyIndicator::markDirty();
 }
 
 QString MainWindow::Window::welcome()
 {
     QString configFileName;
     QPointer<MainWindow::WelcomeDialog> dialog = new WelcomeDialog(this);
     // exit if the user dismissed the welcome dialog
     if (!dialog->exec()) {
         qApp->quit();
     }
     configFileName = dialog->configFileName();
     delete dialog;
     return configFileName;
 }
 
 void MainWindow::Window::closeEvent(QCloseEvent *e)
 {
     bool quit = true;
     quit = slotExit();
     // If I made it here, then the user canceled
     if (!quit)
         e->ignore();
     else
         e->setAccepted(true);
 }
 
 void MainWindow::Window::slotLimitToSelected()
 {
     Utilities::ShowBusyCursor dummy;
     showThumbNails(selected());
 }
 
 void MainWindow::Window::setupMenuBar()
 {
     // File menu
     KStandardAction::save(this, SLOT(slotSave()), actionCollection());
     KStandardAction::quit(this, SLOT(slotExit()), actionCollection());
     m_generateHtml = actionCollection()->addAction(QString::fromLatin1("exportHTML"));
     m_generateHtml->setText(i18n("Generate HTML..."));
     connect(m_generateHtml, &QAction::triggered, this, &Window::slotExportToHTML);
 
     QAction *a = actionCollection()->addAction(QString::fromLatin1("import"), this, SLOT(slotImport()));
     a->setText(i18n("Import..."));
 
     a = actionCollection()->addAction(QString::fromLatin1("export"), this, SLOT(slotExport()));
     a->setText(i18n("Export/Copy Images..."));
 
     // Go menu
     a = KStandardAction::back(m_browser, SLOT(back()), actionCollection());
     connect(m_browser, &Browser::BrowserWidget::canGoBack, a, &QAction::setEnabled);
     a->setEnabled(false);
 
     a = KStandardAction::forward(m_browser, SLOT(forward()), actionCollection());
     connect(m_browser, &Browser::BrowserWidget::canGoForward, a, &QAction::setEnabled);
     a->setEnabled(false);
 
     a = KStandardAction::home(m_browser, SLOT(home()), actionCollection());
     actionCollection()->setDefaultShortcut(a, Qt::CTRL + Qt::Key_Home);
     connect(a, &QAction::triggered, m_dateBar, &DateBar::DateBarWidget::clearSelection);
 
     KStandardAction::redisplay(m_browser, SLOT(go()), actionCollection());
 
     // The Edit menu
     m_copy = KStandardAction::copy(this, SLOT(slotCopySelectedURLs()), actionCollection());
     m_paste = KStandardAction::paste(this, SLOT(slotPasteInformation()), actionCollection());
     m_paste->setEnabled(false);
     m_selectAll = KStandardAction::selectAll(m_thumbnailView, SLOT(selectAll()), actionCollection());
     m_clearSelection = KStandardAction::deselect(m_thumbnailView, SLOT(clearSelection()), actionCollection());
     m_clearSelection->setEnabled(false);
     KStandardAction::find(this, SLOT(slotSearch()), actionCollection());
 
     m_deleteSelected = actionCollection()->addAction(QString::fromLatin1("deleteSelected"));
     m_deleteSelected->setText(i18nc("Delete selected images", "Delete Selected"));
     m_deleteSelected->setIcon(QIcon::fromTheme(QString::fromLatin1("edit-delete")));
     actionCollection()->setDefaultShortcut(m_deleteSelected, Qt::Key_Delete);
     connect(m_deleteSelected, &QAction::triggered, this, &Window::slotDeleteSelected);
 
     a = actionCollection()->addAction(QString::fromLatin1("removeTokens"), this, SLOT(slotRemoveTokens()));
     a->setText(i18n("Remove Tokens..."));
 
     a = actionCollection()->addAction(QString::fromLatin1("showListOfFiles"), this, SLOT(slotShowListOfFiles()));
     a->setText(i18n("Open List of Files..."));
 
     m_configOneAtATime = actionCollection()->addAction(QString::fromLatin1("oneProp"), this, SLOT(slotConfigureImagesOneAtATime()));
     m_configOneAtATime->setText(i18n("Annotate Individual Items"));
     actionCollection()->setDefaultShortcut(m_configOneAtATime, Qt::CTRL + Qt::Key_1);
 
     m_configAllSimultaniously = actionCollection()->addAction(QString::fromLatin1("allProp"), this, SLOT(slotConfigureAllImages()));
     m_configAllSimultaniously->setText(i18n("Annotate Multiple Items at a Time"));
     actionCollection()->setDefaultShortcut(m_configAllSimultaniously, Qt::CTRL + Qt::Key_2);
 
     m_createImageStack = actionCollection()->addAction(QString::fromLatin1("createImageStack"), this, SLOT(slotCreateImageStack()));
     m_createImageStack->setText(i18n("Merge Images into a Stack"));
     actionCollection()->setDefaultShortcut(m_createImageStack, Qt::CTRL + Qt::Key_3);
 
     m_unStackImages = actionCollection()->addAction(QString::fromLatin1("unStackImages"), this, SLOT(slotUnStackImages()));
     m_unStackImages->setText(i18n("Remove Images from Stack"));
 
     m_setStackHead = actionCollection()->addAction(QString::fromLatin1("setStackHead"), this, SLOT(slotSetStackHead()));
     m_setStackHead->setText(i18n("Set as First Image in Stack"));
     actionCollection()->setDefaultShortcut(m_setStackHead, Qt::CTRL + Qt::Key_4);
 
     m_rotLeft = actionCollection()->addAction(QString::fromLatin1("rotateLeft"), this, SLOT(slotRotateSelectedLeft()));
     m_rotLeft->setText(i18n("Rotate counterclockwise"));
     actionCollection()->setDefaultShortcut(m_rotLeft, Qt::Key_7);
 
     m_rotRight = actionCollection()->addAction(QString::fromLatin1("rotateRight"), this, SLOT(slotRotateSelectedRight()));
     m_rotRight->setText(i18n("Rotate clockwise"));
     actionCollection()->setDefaultShortcut(m_rotRight, Qt::Key_9);
 
     // The Images menu
     m_view = actionCollection()->addAction(QString::fromLatin1("viewImages"), this, SLOT(slotView()));
     m_view->setText(i18n("View"));
     actionCollection()->setDefaultShortcut(m_view, Qt::CTRL + Qt::Key_I);
 
     m_viewInNewWindow = actionCollection()->addAction(QString::fromLatin1("viewImagesNewWindow"), this, SLOT(slotViewNewWindow()));
     m_viewInNewWindow->setText(i18n("View (In New Window)"));
 
     m_runSlideShow = actionCollection()->addAction(QString::fromLatin1("runSlideShow"), this, SLOT(slotRunSlideShow()));
     m_runSlideShow->setText(i18n("Run Slide Show"));
     m_runSlideShow->setIcon(QIcon::fromTheme(QString::fromLatin1("view-presentation")));
     actionCollection()->setDefaultShortcut(m_runSlideShow, Qt::CTRL + Qt::Key_R);
 
     m_runRandomSlideShow = actionCollection()->addAction(QString::fromLatin1("runRandomizedSlideShow"), this, SLOT(slotRunRandomizedSlideShow()));
     m_runRandomSlideShow->setText(i18n("Run Randomized Slide Show"));
 
     a = actionCollection()->addAction(QString::fromLatin1("collapseAllStacks"),
                                       m_thumbnailView, SLOT(collapseAllStacks()));
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::collapseAllStacksEnabled, a, &QAction::setEnabled);
     a->setEnabled(false);
     a->setText(i18n("Collapse all stacks"));
 
     a = actionCollection()->addAction(QString::fromLatin1("expandAllStacks"),
                                       m_thumbnailView, SLOT(expandAllStacks()));
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::expandAllStacksEnabled, a, &QAction::setEnabled);
     a->setEnabled(false);
     a->setText(i18n("Expand all stacks"));
 
     QActionGroup *grp = new QActionGroup(this);
 
     a = actionCollection()->add<KToggleAction>(QString::fromLatin1("orderIncr"), this, SLOT(slotOrderIncr()));
     a->setText(i18n("Show &Oldest First"));
     a->setActionGroup(grp);
     a->setChecked(!Settings::SettingsData::instance()->showNewestThumbnailFirst());
 
     a = actionCollection()->add<KToggleAction>(QString::fromLatin1("orderDecr"), this, SLOT(slotOrderDecr()));
     a->setText(i18n("Show &Newest First"));
     a->setActionGroup(grp);
     a->setChecked(Settings::SettingsData::instance()->showNewestThumbnailFirst());
 
     m_sortByDateAndTime = actionCollection()->addAction(QString::fromLatin1("sortImages"), this, SLOT(slotSortByDateAndTime()));
     m_sortByDateAndTime->setText(i18n("Sort Selected by Date && Time"));
 
     m_limitToMarked = actionCollection()->addAction(QString::fromLatin1("limitToMarked"), this, SLOT(slotLimitToSelected()));
     m_limitToMarked->setText(i18n("Limit View to Selection"));
 
     m_jumpToContext = actionCollection()->addAction(QString::fromLatin1("jumpToContext"), this, SLOT(slotJumpToContext()));
     m_jumpToContext->setText(i18n("Jump to Context"));
     actionCollection()->setDefaultShortcut(m_jumpToContext, Qt::CTRL + Qt::Key_J);
     m_jumpToContext->setIcon(QIcon::fromTheme(QString::fromLatin1("kphotoalbum"))); // icon suggestion: go-jump (don't know the exact meaning though, so I didn't replace it right away
 
     m_lock = actionCollection()->addAction(QString::fromLatin1("lockToDefaultScope"), this, SLOT(lockToDefaultScope()));
     m_lock->setText(i18n("Lock Images"));
 
     m_unlock = actionCollection()->addAction(QString::fromLatin1("unlockFromDefaultScope"), this, SLOT(unlockFromDefaultScope()));
     m_unlock->setText(i18n("Unlock"));
 
     a = actionCollection()->addAction(QString::fromLatin1("changeScopePasswd"), this, SLOT(changePassword()));
     a->setText(i18n("Change Password..."));
     actionCollection()->setDefaultShortcut(a, 0);
 
     m_setDefaultPos = actionCollection()->addAction(QString::fromLatin1("setDefaultScopePositive"), this, SLOT(setDefaultScopePositive()));
     m_setDefaultPos->setText(i18n("Lock Away All Other Items"));
 
     m_setDefaultNeg = actionCollection()->addAction(QString::fromLatin1("setDefaultScopeNegative"), this, SLOT(setDefaultScopeNegative()));
     m_setDefaultNeg->setText(i18n("Lock Away Current Set of Items"));
 
     // Maintenance
     a = actionCollection()->addAction(QString::fromLatin1("findUnavailableImages"), this, SLOT(slotShowNotOnDisk()));
     a->setText(i18n("Display Images and Videos Not on Disk"));
 
     a = actionCollection()->addAction(QString::fromLatin1("findImagesWithInvalidDate"), this, SLOT(slotShowImagesWithInvalidDate()));
     a->setText(i18n("Display Images and Videos with Incomplete Dates..."));
 
 #ifdef DOES_STILL_NOT_WORK_IN_KPA4
     a = actionCollection()->addAction(QString::fromLatin1("findImagesWithChangedMD5Sum"), this, SLOT(slotShowImagesWithChangedMD5Sum()));
     a->setText(i18n("Display Images and Videos with Changed MD5 Sum"));
 #endif //DOES_STILL_NOT_WORK_IN_KPA4
 
     a = actionCollection()->addAction(QLatin1String("mergeDuplicates"), this, SLOT(mergeDuplicates()));
     a->setText(i18n("Merge duplicates"));
     a = actionCollection()->addAction(QString::fromLatin1("rebuildMD5s"), this, SLOT(slotRecalcCheckSums()));
     a->setText(i18n("Recalculate Checksum"));
 
     a = actionCollection()->addAction(QString::fromLatin1("rescan"), DB::ImageDB::instance(), SLOT(slotRescan()));
     a->setIcon(QIcon::fromTheme(QString::fromLatin1("document-import")));
     a->setText(i18n("Rescan for Images and Videos"));
 
     QAction *recreateExif = actionCollection()->addAction(QString::fromLatin1("recreateExifDB"), this, SLOT(slotRecreateExifDB()));
     recreateExif->setText(i18n("Recreate Exif Search Database"));
 
     QAction *rereadExif = actionCollection()->addAction(QString::fromLatin1("reReadExifInfo"), this, SLOT(slotReReadExifInfo()));
     rereadExif->setText(i18n("Read Exif Info from Files..."));
 
     m_sortAllByDateAndTime = actionCollection()->addAction(QString::fromLatin1("sortAllImages"), this, SLOT(slotSortAllByDateAndTime()));
     m_sortAllByDateAndTime->setText(i18n("Sort All by Date && Time"));
     m_sortAllByDateAndTime->setEnabled(true);
 
     m_AutoStackImages = actionCollection()->addAction(QString::fromLatin1("autoStack"), this, SLOT(slotAutoStackImages()));
     m_AutoStackImages->setText(i18n("Automatically Stack Selected Images..."));
 
     a = actionCollection()->addAction(QString::fromLatin1("buildThumbs"), this, SLOT(slotBuildThumbnails()));
     a->setText(i18n("Build Thumbnails"));
 
     a = actionCollection()->addAction(QString::fromLatin1("statistics"), this, SLOT(slotStatistics()));
     a->setText(i18n("Statistics..."));
 
     m_markUntagged = actionCollection()->addAction(QString::fromUtf8("markUntagged"),
                                                    this, SLOT(slotMarkUntagged()));
     m_markUntagged->setText(i18n("Mark As Untagged"));
 
-    // Settings
+    // The Settings menu
     KStandardAction::preferences(this, SLOT(slotOptions()), actionCollection());
     KStandardAction::keyBindings(this, SLOT(slotConfigureKeyBindings()), actionCollection());
     KStandardAction::configureToolbars(this, SLOT(slotConfigureToolbars()), actionCollection());
 
     a = actionCollection()->addAction(QString::fromLatin1("readdAllMessages"), this, SLOT(slotReenableMessages()));
     a->setText(i18n("Enable All Messages"));
 
     m_viewMenu = actionCollection()->add<KActionMenu>(QString::fromLatin1("configureView"));
     m_viewMenu->setText(i18n("Configure Current View"));
     m_viewMenu->setIcon(QIcon::fromTheme(QString::fromLatin1("view-list-details")));
     m_viewMenu->setDelayed(false);
 
     QActionGroup *viewGrp = new QActionGroup(this);
     viewGrp->setExclusive(true);
 
     m_smallListView = actionCollection()->add<KToggleAction>(QString::fromLatin1("smallListView"), m_browser, SLOT(slotSmallListView()));
     m_smallListView->setText(i18n("Tree"));
     m_viewMenu->addAction(m_smallListView);
     m_smallListView->setActionGroup(viewGrp);
 
     m_largeListView = actionCollection()->add<KToggleAction>(QString::fromLatin1("largelistview"), m_browser, SLOT(slotLargeListView()));
     m_largeListView->setText(i18n("Tree with User Icons"));
     m_viewMenu->addAction(m_largeListView);
     m_largeListView->setActionGroup(viewGrp);
 
     m_largeIconView = actionCollection()->add<KToggleAction>(QString::fromLatin1("largeiconview"), m_browser, SLOT(slotLargeIconView()));
     m_largeIconView->setText(i18n("Icons"));
     m_viewMenu->addAction(m_largeIconView);
     m_largeIconView->setActionGroup(viewGrp);
 
     connect(m_browser, &Browser::BrowserWidget::isViewChangeable, viewGrp, &QActionGroup::setEnabled);
     connect(m_browser, &Browser::BrowserWidget::currentViewTypeChanged, this, &Window::slotUpdateViewMenu);
 
     a = actionCollection()->add<KToggleAction>(QString::fromLatin1("showToolTipOnImages"));
     a->setText(i18n("Show Tooltips in Thumbnails Window"));
     actionCollection()->setDefaultShortcut(a, Qt::CTRL + Qt::Key_T);
     connect(a, &QAction::toggled, m_thumbnailView, &ThumbnailView::ThumbnailFacade::showToolTipsOnImages);
 
     QAction *toggleFilterToolbar = actionCollection()->add<KToggleAction>(QString::fromLatin1("toggleFilterToolbar"));
     toggleFilterToolbar->setText(i18n("Show filter toolbar"));
     toggleFilterToolbar->setIcon(QIcon::fromTheme(QString::fromLatin1("view-filter")));
     // connections are done in createSearchBar()
 
     QAction *toggleSearchBar = actionCollection()->add<KToggleAction>(QString::fromLatin1("toggleSearchBar"));
     toggleSearchBar->setText(i18n("Show search bar"));
     toggleSearchBar->setIcon(QIcon::fromTheme(QString::fromLatin1("search")));
     // connections are done in createSearchBar()
 
+    KColorSchemeManager *schemes = new KColorSchemeManager(this);
+    m_colorSchemeMenu = schemes->createSchemeSelectionMenu(Settings::SettingsData::instance()->colorScheme(), this);
+    m_colorSchemeMenu->setText(i18n("Choose color scheme"));
+    m_colorSchemeMenu->setIcon(QIcon::fromTheme(QString::fromLatin1("color")));
+    m_colorSchemeMenu->setDelayed(false);
+    actionCollection()->addAction(QString::fromLatin1("colorScheme"), m_colorSchemeMenu);
+
     // The help menu
     KStandardAction::tipOfDay(this, SLOT(showTipOfDay()), actionCollection());
 
     a = actionCollection()->addAction(QString::fromLatin1("runDemo"), this, SLOT(runDemo()));
     a->setText(i18n("Run KPhotoAlbum Demo"));
 
     a = actionCollection()->addAction(QString::fromLatin1("features"), this, SLOT(showFeatures()));
     a->setText(i18n("KPhotoAlbum Feature Status"));
 
     a = actionCollection()->addAction(QString::fromLatin1("showVideo"), this, SLOT(showVideos()));
     a->setText(i18n("Show Demo Videos"));
 
     // Context menu actions
     m_showExifDialog = actionCollection()->addAction(QString::fromLatin1("showExifInfo"), this, SLOT(slotShowExifInfo()));
     m_showExifDialog->setText(i18n("Show Exif Info"));
 
     m_recreateThumbnails = actionCollection()->addAction(QString::fromLatin1("recreateThumbnails"), m_thumbnailView, SLOT(slotRecreateThumbnail()));
     m_recreateThumbnails->setText(i18n("Recreate Selected Thumbnails"));
 
     m_useNextVideoThumbnail = actionCollection()->addAction(QString::fromLatin1("useNextVideoThumbnail"), this, SLOT(useNextVideoThumbnail()));
     m_useNextVideoThumbnail->setText(i18n("Use next video thumbnail"));
     actionCollection()->setDefaultShortcut(m_useNextVideoThumbnail, Qt::CTRL + Qt::Key_Plus);
 
     m_usePreviousVideoThumbnail = actionCollection()->addAction(QString::fromLatin1("usePreviousVideoThumbnail"), this, SLOT(usePreviousVideoThumbnail()));
     m_usePreviousVideoThumbnail->setText(i18n("Use previous video thumbnail"));
     actionCollection()->setDefaultShortcut(m_usePreviousVideoThumbnail, Qt::CTRL + Qt::Key_Minus);
 
     createGUI(QString::fromLatin1("kphotoalbumui.rc"));
 }
 
 void MainWindow::Window::slotExportToHTML()
 {
     if (!m_htmlDialog)
         m_htmlDialog = new HTMLGenerator::HTMLDialog(this);
     m_htmlDialog->exec(selectedOnDisk());
 }
 
 void MainWindow::Window::startAutoSaveTimer()
 {
     int i = Settings::SettingsData::instance()->autoSave();
     m_autoSaveTimer->stop();
     if (i != 0) {
         m_autoSaveTimer->start(i * 1000 * 60);
     }
 }
 
 void MainWindow::Window::slotAutoSave()
 {
     if (m_statusBar->mp_dirtyIndicator->isAutoSaveDirty()) {
         Utilities::ShowBusyCursor dummy;
         m_statusBar->showMessage(i18n("Auto saving...."));
         DB::ImageDB::instance()->save(Settings::SettingsData::instance()->imageDirectory() + QString::fromLatin1(".#index.xml"), true);
         ImageManager::ThumbnailCache::instance()->save();
         m_statusBar->showMessage(i18n("Auto saving.... Done"), 5000);
         m_statusBar->mp_dirtyIndicator->autoSaved();
     }
 }
 
 void MainWindow::Window::showThumbNails()
 {
     m_statusBar->showThumbnailSlider();
     reloadThumbnails(ThumbnailView::ClearSelection);
     m_stack->setCurrentWidget(m_thumbnailView->gui());
     m_thumbnailView->gui()->setFocus();
     updateStates(true);
 }
 
 void MainWindow::Window::showBrowser()
 {
     m_statusBar->clearMessage();
     m_statusBar->hideThumbnailSlider();
     m_stack->setCurrentWidget(m_browser);
     m_browser->setFocus();
     updateContextMenuFromSelectionSize(0);
     updateStates(false);
 }
 
 void MainWindow::Window::slotOptionGroupChanged()
 {
     // FIXME: What if annotation dialog is open? (if that's possible)
     delete m_annotationDialog;
     m_annotationDialog = nullptr;
     DirtyIndicator::markDirty();
 }
 
 void MainWindow::Window::showTipOfDay()
 {
     KTipDialog::showTip(this, QString(), true);
 }
 
 void MainWindow::Window::runDemo()
 {
     KProcess *process = new KProcess;
     *process << qApp->applicationFilePath() << QLatin1String("--demo");
     process->startDetached();
 }
 
 bool MainWindow::Window::load()
 {
     // Let first try to find a config file.
     QString configFile;
 
     QUrl dbFileUrl = Options::the()->dbFile();
     if (!dbFileUrl.isEmpty() && dbFileUrl.isLocalFile()) {
         configFile = dbFileUrl.toLocalFile();
     } else if (Options::the()->demoMode()) {
         configFile = Utilities::setupDemo();
     } else {
         bool showWelcome = false;
         KConfigGroup config = KSharedConfig::openConfig()->group(QString::fromUtf8("General"));
         if (config.hasKey(QString::fromLatin1("imageDBFile"))) {
             configFile = config.readEntry<QString>(QString::fromLatin1("imageDBFile"), QString());
             if (!QFileInfo(configFile).exists())
                 showWelcome = true;
         } else
             showWelcome = true;
 
         if (showWelcome) {
             SplashScreen::instance()->hide();
             configFile = welcome();
         }
     }
     if (configFile.isNull())
         return false;
 
     if (configFile.startsWith(QString::fromLatin1("~")))
         configFile = QDir::home().path() + QString::fromLatin1("/") + configFile.mid(1);
 
     // To avoid a race conditions where both the image loader thread creates an instance of
     // Settings, and where the main thread crates an instance, we better get it created now.
     Settings::SettingsData::setup(QFileInfo(configFile).absolutePath());
 
     if (Settings::SettingsData::instance()->showSplashScreen()) {
         SplashScreen::instance()->show();
         qApp->processEvents();
     }
 
     // Doing some validation on user provided index file
     if (Options::the()->dbFile().isValid()) {
         QFileInfo fi(configFile);
 
         if (!fi.dir().exists()) {
             KMessageBox::error(this, i18n("<p>Could not open given index.xml as provided directory does not exist.<br />%1</p>", fi.absolutePath()));
             return false;
         }
 
         // We use index.xml as the XML backend, thus we want to test for exactly it
         fi.setFile(QString::fromLatin1("%1/index.xml").arg(fi.dir().absolutePath()));
         if (!fi.exists()) {
             int answer = KMessageBox::questionYesNo(this, i18n("<p>Given index file does not exist, do you want to create following?"
                                                                "<br />%1/index.xml</p>",
                                                                fi.absolutePath()));
             if (answer != KMessageBox::Yes)
                 return false;
         }
         configFile = fi.absoluteFilePath();
     }
     DB::ImageDB::setupXMLDB(configFile, *this);
 
     // some sanity checks:
     if (!Settings::SettingsData::instance()->hasUntaggedCategoryFeatureConfigured()
         && !(Settings::SettingsData::instance()->untaggedCategory().isEmpty()
              && Settings::SettingsData::instance()->untaggedTag().isEmpty())
         && !Options::the()->demoMode()) {
         KMessageBox::error(this, i18n("<p>You have configured a tag for untagged images, but either the tag itself "
                                       "or its category does not exist in the database.</p>"
                                       "<p>Please review your untagged tag setting under "
                                       "<interface>Settings|Configure KPhotoAlbum...|Categories</interface></p>"));
     }
 
     return true;
 }
 
 void MainWindow::Window::contextMenuEvent(QContextMenuEvent *e)
 {
     if (m_stack->currentWidget() == m_thumbnailView->gui()) {
         QMenu menu(this);
         menu.addAction(m_configOneAtATime);
         menu.addAction(m_configAllSimultaniously);
         menu.addSeparator();
         menu.addAction(m_createImageStack);
         menu.addAction(m_unStackImages);
         menu.addAction(m_setStackHead);
         menu.addSeparator();
         menu.addAction(m_runSlideShow);
         menu.addAction(m_runRandomSlideShow);
         menu.addAction(m_showExifDialog);
 
         menu.addSeparator();
         menu.addAction(m_rotLeft);
         menu.addAction(m_rotRight);
         menu.addAction(m_recreateThumbnails);
         menu.addAction(m_useNextVideoThumbnail);
         menu.addAction(m_usePreviousVideoThumbnail);
         m_useNextVideoThumbnail->setEnabled(anyVideosSelected());
         m_usePreviousVideoThumbnail->setEnabled(anyVideosSelected());
         menu.addSeparator();
 
         menu.addAction(m_view);
         menu.addAction(m_viewInNewWindow);
 
         // "Invoke external program"
 
         ExternalPopup externalCommands { &menu };
         DB::ImageInfoPtr info = m_thumbnailView->mediaIdUnderCursor().info();
 
         externalCommands.populate(info, selected());
         QAction *action = menu.addMenu(&externalCommands);
         if (!info && selected().isEmpty())
             action->setEnabled(false);
 
         QUrl selectedFile;
         if (info)
             selectedFile = QUrl::fromLocalFile(info->fileName().absolute());
         QList<QUrl> allSelectedFiles;
         for (const QString &selectedPath : selected().toStringList(DB::AbsolutePath)) {
             allSelectedFiles << QUrl::fromLocalFile(selectedPath);
         }
 
         // "Copy image(s) to ..."
         CopyPopup copyMenu(&menu, selectedFile, allSelectedFiles, m_lastTarget, CopyPopup::Copy);
         QAction *copyAction = menu.addMenu(&copyMenu);
         if (!info && selected().isEmpty()) {
             copyAction->setEnabled(false);
         }
 
         // "Link image(s) to ..."
         CopyPopup linkMenu(&menu, selectedFile, allSelectedFiles, m_lastTarget, CopyPopup::Link);
         QAction *linkAction = menu.addMenu(&linkMenu);
         if (!info && selected().isEmpty()) {
             linkAction->setEnabled(false);
         }
 
         menu.exec(QCursor::pos());
     }
     e->setAccepted(true);
 }
 
 void MainWindow::Window::setDefaultScopePositive()
 {
     Settings::SettingsData::instance()->setCurrentLock(m_browser->currentContext(), false);
 }
 
 void MainWindow::Window::setDefaultScopeNegative()
 {
     Settings::SettingsData::instance()->setCurrentLock(m_browser->currentContext(), true);
 }
 
 void MainWindow::Window::lockToDefaultScope()
 {
     int i = KMessageBox::warningContinueCancel(this,
                                                i18n("<p>The password protection is only a means of allowing your little sister "
                                                     "to look in your images, without getting to those embarrassing images from "
                                                     "your last party.</p>"
                                                     "<p><b>In other words, anyone with access to the index.xml file can easily "
                                                     "circumvent this password.</b></p>"),
                                                i18n("Password Protection"),
                                                KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
                                                QString::fromLatin1("lockPassWordIsNotEncruption"));
     if (i == KMessageBox::Cancel)
         return;
 
     setLocked(true, false);
 }
 
 void MainWindow::Window::unlockFromDefaultScope()
 {
     bool OK = (Settings::SettingsData::instance()->password().isEmpty());
     QPointer<KPasswordDialog> dialog = new KPasswordDialog(this);
     while (!OK) {
         dialog->setPrompt(i18n("Type in Password to Unlock"));
         const int code = dialog->exec();
         if (code == QDialog::Rejected)
             return;
         const QString passwd = dialog->password();
 
         OK = (Settings::SettingsData::instance()->password() == passwd);
 
         if (!OK)
             KMessageBox::sorry(this, i18n("Invalid password."));
     }
     setLocked(false, false);
     delete dialog;
 }
 
 void MainWindow::Window::setLocked(bool locked, bool force, bool recount)
 {
     m_statusBar->setLocked(locked);
     Settings::SettingsData::instance()->setLocked(locked, force);
 
     m_lock->setEnabled(!locked);
     m_unlock->setEnabled(locked);
     m_setDefaultPos->setEnabled(!locked);
     m_setDefaultNeg->setEnabled(!locked);
     if (recount)
         m_browser->reload();
 }
 
 void MainWindow::Window::changePassword()
 {
     bool OK = (Settings::SettingsData::instance()->password().isEmpty());
 
     QPointer<KPasswordDialog> dialog = new KPasswordDialog;
 
     while (!OK) {
         dialog->setPrompt(i18n("Type in Old Password"));
         const int code = dialog->exec();
         if (code == QDialog::Rejected)
             return;
         const QString passwd = dialog->password();
 
         OK = (Settings::SettingsData::instance()->password() == QString(passwd));
 
         if (!OK)
             KMessageBox::sorry(this, i18n("Invalid password."));
     }
 
     dialog->setPrompt(i18n("Type in New Password"));
     const int code = dialog->exec();
     if (code == QDialog::Accepted)
         Settings::SettingsData::instance()->setPassword(dialog->password());
     delete dialog;
 }
 
 void MainWindow::Window::slotConfigureKeyBindings()
 {
     Viewer::ViewerWidget *viewer = new Viewer::ViewerWidget; // Do not show, this is only used to get a key configuration
     KShortcutsDialog *dialog = new KShortcutsDialog();
     dialog->addCollection(actionCollection(), i18n("General"));
     dialog->addCollection(viewer->actions(), i18n("Viewer"));
 
 #ifdef HASKIPI
     loadKipiPlugins();
     for (const KIPI::PluginLoader::Info *pluginInfo : m_pluginLoader->pluginList()) {
         KIPI::Plugin *plugin = pluginInfo->plugin();
         if (plugin)
             dialog->addCollection(plugin->actionCollection(),
                                   i18nc("Add 'Plugin' prefix so that KIPI plugins are obvious in KShortcutsDialog…", "Plugin: %1", pluginInfo->name()));
     }
 #endif
 
     createAnnotationDialog();
     dialog->addCollection(m_annotationDialog->actions(), i18n("Annotation Dialog"));
     dialog->addCollection(m_thumbnailView->actions(), i18n("Thumbnail View"));
 
     dialog->configure();
 
     delete dialog;
     delete viewer;
 }
 
 void MainWindow::Window::slotSetFileName(const DB::FileName &fileName)
 {
     ImageInfoPtr info;
 
     if (fileName.isNull())
         m_statusBar->clearMessage();
     else {
         info = fileName.info();
         if (info != ImageInfoPtr(nullptr))
             m_statusBar->showMessage(fileName.absolute(), 4000);
     }
 }
 
 void MainWindow::Window::updateContextMenuFromSelectionSize(int selectionSize)
 {
     m_configAllSimultaniously->setEnabled(selectionSize > 1);
     m_configOneAtATime->setEnabled(selectionSize >= 1);
     m_createImageStack->setEnabled(selectionSize > 1);
     m_unStackImages->setEnabled(selectionSize >= 1);
     m_setStackHead->setEnabled(selectionSize == 1); // FIXME: do we want to check if it's stacked here?
     m_sortByDateAndTime->setEnabled(selectionSize > 1);
     m_recreateThumbnails->setEnabled(selectionSize >= 1);
     m_rotLeft->setEnabled(selectionSize >= 1);
     m_rotRight->setEnabled(selectionSize >= 1);
     m_AutoStackImages->setEnabled(selectionSize > 1);
     m_markUntagged->setEnabled(selectionSize >= 1);
     m_statusBar->mp_selected->setSelectionCount(selectionSize);
     m_clearSelection->setEnabled(selectionSize > 0);
 }
 
 void MainWindow::Window::rotateSelected(int angle)
 {
     const DB::FileNameList list = selected();
     if (list.isEmpty()) {
         KMessageBox::sorry(this, i18n("No item is selected."),
                            i18n("No Selection"));
     } else {
         for (const DB::FileName &fileName : list) {
             fileName.info()->rotate(angle);
             ImageManager::ThumbnailCache::instance()->removeThumbnail(fileName);
         }
         m_statusBar->mp_dirtyIndicator->markDirty();
     }
 }
 
 void MainWindow::Window::slotRotateSelectedLeft()
 {
     rotateSelected(-90);
     reloadThumbnails();
 }
 
 void MainWindow::Window::slotRotateSelectedRight()
 {
     rotateSelected(90);
     reloadThumbnails();
 }
 
 void MainWindow::Window::reloadThumbnails(ThumbnailView::SelectionUpdateMethod method)
 {
     m_thumbnailView->reload(method);
     updateContextMenuFromSelectionSize(m_thumbnailView->selection().size());
 }
 
 void MainWindow::Window::slotUpdateViewMenu(DB::Category::ViewType type)
 {
     if (type == DB::Category::TreeView)
         m_smallListView->setChecked(true);
     else if (type == DB::Category::ThumbedTreeView)
         m_largeListView->setChecked(true);
     else if (type == DB::Category::ThumbedIconView)
         m_largeIconView->setChecked(true);
 }
 
 void MainWindow::Window::slotShowNotOnDisk()
 {
     DB::FileNameList notOnDisk;
     const auto allImages = DB::ImageDB::instance()->images();
     for (const DB::FileName &fileName : allImages) {
         if (!fileName.exists())
             notOnDisk.append(fileName);
     }
 
     showThumbNails(notOnDisk);
 }
 
 void MainWindow::Window::slotShowImagesWithChangedMD5Sum()
 {
 #ifdef DOES_STILL_NOT_WORK_IN_KPA4
     Utilities::ShowBusyCursor dummy;
     StringSet changed = DB::ImageDB::instance()->imagesWithMD5Changed();
     showThumbNails(changed.toList());
 #else // DOES_STILL_NOT_WORK_IN_KPA4
     qFatal("Code commented out in MainWindow::Window::slotShowImagesWithChangedMD5Sum");
 #endif // DOES_STILL_NOT_WORK_IN_KPA4
 }
 
 void MainWindow::Window::updateStates(bool thumbNailView)
 {
     m_selectAll->setEnabled(thumbNailView);
     m_deleteSelected->setEnabled(thumbNailView);
     m_limitToMarked->setEnabled(thumbNailView);
     m_jumpToContext->setEnabled(thumbNailView);
 }
 
 void MainWindow::Window::slotRunSlideShow()
 {
     slotView(true, true);
 }
 
 void MainWindow::Window::slotRunRandomizedSlideShow()
 {
     slotView(true, true, true);
 }
 
 MainWindow::Window *MainWindow::Window::theMainWindow()
 {
     Q_ASSERT(s_instance);
     return s_instance;
 }
 
 void MainWindow::Window::slotConfigureToolbars()
 {
     QPointer<KEditToolBar> dlg = new KEditToolBar(guiFactory());
     connect(dlg, &KEditToolBar::newToolBarConfig,
             this, &Window::slotNewToolbarConfig);
     dlg->exec();
     delete dlg;
 }
 
 void MainWindow::Window::slotNewToolbarConfig()
 {
     createGUI();
     createSearchBar();
 }
 
 void MainWindow::Window::slotImport()
 {
     ImportExport::Import::imageImport();
 }
 
 void MainWindow::Window::slotExport()
 {
     ImportExport::Export::imageExport(selectedOnDisk());
 }
 
 void MainWindow::Window::slotReenableMessages()
 {
     int ret = KMessageBox::questionYesNo(this, i18n("<p>Really enable all message boxes where you previously "
                                                     "checked the do-not-show-again check box?</p>"));
     if (ret == KMessageBox::Yes)
         KMessageBox::enableAllMessages();
 }
 
 void MainWindow::Window::setupPluginMenu()
 {
     QMenu *menu = findChild<QMenu *>(QString::fromLatin1("plugins"));
     if (!menu) {
         KMessageBox::error(this, i18n("<p>KPhotoAlbum hit an internal error (missing plug-in menu in MainWindow::Window::setupPluginMenu). This indicate that you forgot to do a make install. If you did compile KPhotoAlbum yourself, then please run make install. If not, please report this as a bug.</p><p>KPhotoAlbum will continue execution, but it is not entirely unlikely that it will crash later on due to the missing make install.</p>"), i18n("Internal Error"));
         m_hasLoadedKipiPlugins = true;
         return; // This is no good, but lets try and continue.
     }
 
 #ifdef KF5Purpose_FOUND
     Plugins::PurposeMenu *purposeMenu = new Plugins::PurposeMenu(menu);
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::selectionChanged,
             purposeMenu, &Plugins::PurposeMenu::slotSelectionChanged);
     connect(purposeMenu, &Plugins::PurposeMenu::imageShared, [this](QUrl shareLocation) {
         QString message;
         if (shareLocation.isValid()) {
             message = i18n("Successfully shared image(s). Copying location to clipboard...");
             QGuiApplication::clipboard()->setText(shareLocation.toString());
         } else {
             message = i18n("Successfully shared image(s).");
         }
         m_statusBar->showMessage(message);
     });
     connect(purposeMenu, &Plugins::PurposeMenu::imageSharingFailed, [this](QString errorMessage) {
         QString message = i18n("Image sharing failed with message: %1", errorMessage);
         m_statusBar->showMessage(message);
     });
 #endif
 
 #ifdef HASKIPI
     connect(menu, &QMenu::aboutToShow, this, &Window::loadKipiPlugins);
     m_hasLoadedKipiPlugins = false;
 #else
     setPluginMenuState("kipiplugins", {});
 #ifndef KF5Purpose_FOUND
     menu->setEnabled(false);
 #endif
     m_hasLoadedKipiPlugins = true;
 #endif
 }
 
 void MainWindow::Window::loadKipiPlugins()
 {
 #ifdef HASKIPI
     Utilities::ShowBusyCursor dummy;
     if (m_hasLoadedKipiPlugins)
         return;
 
     m_pluginInterface = new Plugins::Interface(this, QString::fromLatin1("KPhotoAlbum kipi interface"));
     connect(m_pluginInterface, &Plugins::Interface::imagesChanged, this, &Window::slotImagesChanged);
 
     QStringList ignores;
     ignores << QString::fromLatin1("CommentsEditor")
             << QString::fromLatin1("HelloWorld");
 
     m_pluginLoader = new KIPI::PluginLoader();
     m_pluginLoader->setIgnoredPluginsList(ignores);
     m_pluginLoader->setInterface(m_pluginInterface);
     m_pluginLoader->init();
     connect(m_pluginLoader, &KIPI::PluginLoader::replug, this, &Window::plug);
     m_pluginLoader->loadPlugins();
 
     // Setup signals
     connect(m_thumbnailView, &ThumbnailView::ThumbnailFacade::selectionChanged, this, &Window::slotSelectionChanged);
     m_hasLoadedKipiPlugins = true;
 
     // Make sure selection is updated also when plugin loading is
     // delayed. This is needed, because selection might already be
     // non-empty when loading the plugins.
     slotSelectionChanged(selected().size());
 #endif // HASKIPI
 }
 
 void MainWindow::Window::plug()
 {
 #ifdef HASKIPI
     unplugActionList(QString::fromLatin1("kipi_actions"));
 
     QList<QAction *> kipiActions;
 
     KIPI::PluginLoader::PluginList list = m_pluginLoader->pluginList();
     for (const KIPI::PluginLoader::Info *pluginInfo : list) {
         KIPI::Plugin *plugin = pluginInfo->plugin();
         if (!plugin || !pluginInfo->shouldLoad())
             continue;
 
         plugin->setup(this);
 
         QList<QAction *> actions = plugin->actions();
         for (QAction *action : actions) {
             kipiActions.append(action);
         }
         KConfigGroup group = KSharedConfig::openConfig()->group(QString::fromLatin1("Shortcuts"));
         plugin->actionCollection()->importGlobalShortcuts(&group);
     }
 
     setPluginMenuState("kipiplugins", kipiActions);
 
     // For this to work I need to pass false as second arg for createGUI
     plugActionList(QString::fromLatin1("kipi_actions"), kipiActions);
 #endif
 }
 
 void MainWindow::Window::setPluginMenuState(const char *name, const QList<QAction *> &actions)
 {
     QMenu *menu = findChild<QMenu *>(QString::fromLatin1(name));
     if (menu)
         menu->setEnabled(actions.count() != 0);
 }
 
 void MainWindow::Window::slotImagesChanged(const QList<QUrl> &urls)
 {
     for (QList<QUrl>::ConstIterator it = urls.begin(); it != urls.end(); ++it) {
         DB::FileName fileName = DB::FileName::fromAbsolutePath((*it).path());
         if (!fileName.isNull()) {
             // Plugins may report images outsite of the photodatabase
             // This seems to be the case with the border image plugin, which reports the destination image
             ImageManager::ThumbnailCache::instance()->removeThumbnail(fileName);
             // update MD5sum:
             MD5 md5sum = MD5Sum(fileName);
             fileName.info()->setMD5Sum(md5sum);
         }
     }
     m_statusBar->mp_dirtyIndicator->markDirty();
     reloadThumbnails(ThumbnailView::MaintainSelection);
 }
 
 DB::ImageSearchInfo MainWindow::Window::currentContext()
 {
     return m_browser->currentContext();
 }
 
 QString MainWindow::Window::currentBrowseCategory() const
 {
     return m_browser->currentCategory();
 }
 
 void MainWindow::Window::slotSelectionChanged(int count)
 {
 #ifdef HASKIPI
     m_pluginInterface->slotSelectionChanged(count != 0);
 #else
     Q_UNUSED(count)
 #endif
 }
 
 void MainWindow::Window::resizeEvent(QResizeEvent *)
 {
     if (Settings::SettingsData::ready() && isVisible())
         Settings::SettingsData::instance()->setWindowGeometry(Settings::MainWindow, geometry());
 }
 
 void MainWindow::Window::moveEvent(QMoveEvent *)
 {
     if (Settings::SettingsData::ready() && isVisible())
         Settings::SettingsData::instance()->setWindowGeometry(Settings::MainWindow, geometry());
 }
 
 void MainWindow::Window::slotRemoveTokens()
 {
     if (!m_tokenEditor)
         m_tokenEditor = new TokenEditor(this);
     m_tokenEditor->show();
     connect(m_tokenEditor, &TokenEditor::finished, m_browser, &Browser::BrowserWidget::go);
 }
 
 void MainWindow::Window::slotShowListOfFiles()
 {
     QStringList list = QInputDialog::getMultiLineText(this,
                                                       i18n("Open List of Files"),
                                                       i18n("You can open a set of files from KPhotoAlbum's image root by listing the files here."))
                            .split(QChar::fromLatin1('\n'), QString::SkipEmptyParts);
     if (list.isEmpty())
         return;
 
     DB::FileNameList out;
     for (QStringList::const_iterator it = list.constBegin(); it != list.constEnd(); ++it) {
         QString fileNameStr = Utilities::imageFileNameToAbsolute(*it);
         if (fileNameStr.isNull())
             continue;
         const DB::FileName fileName = DB::FileName::fromAbsolutePath(fileNameStr);
         if (!fileName.isNull())
             out.append(fileName);
     }
 
     if (out.isEmpty())
         KMessageBox::sorry(this, i18n("No images matching your input were found."), i18n("No Matches"));
     else
         showThumbNails(out);
 }
 
 void MainWindow::Window::updateDateBar(const Browser::BreadcrumbList &path)
 {
     static QString lastPath = QString::fromLatin1("ThisStringShouldNeverBeSeenSoWeUseItAsInitialContent");
     if (path.toString() != lastPath)
         updateDateBar();
     lastPath = path.toString();
 }
 
 void MainWindow::Window::updateDateBar()
 {
     m_dateBar->setImageDateCollection(DB::ImageDB::instance()->rangeCollection());
 }
 
 void MainWindow::Window::slotShowImagesWithInvalidDate()
 {
     QPointer<InvalidDateFinder> finder = new InvalidDateFinder(this);
     if (finder->exec() == QDialog::Accepted)
         showThumbNails();
     delete finder;
 }
 
 void MainWindow::Window::showDateBarTip(const QString &msg)
 {
     m_statusBar->showMessage(msg, 3000);
 }
 
 void MainWindow::Window::slotJumpToContext()
 {
     const DB::FileName fileName = m_thumbnailView->currentItem();
     if (!fileName.isNull()) {
         m_browser->addImageView(fileName);
     }
 }
 
 void MainWindow::Window::setDateRange(const DB::ImageDate &range)
 {
     DB::ImageDB::instance()->setDateRange(range, m_dateBar->includeFuzzyCounts());
     m_statusBar->mp_partial->showBrowserMatches(this->selected().size());
     m_browser->reload();
     reloadThumbnails(ThumbnailView::MaintainSelection);
 }
 
 void MainWindow::Window::clearDateRange()
 {
     DB::ImageDB::instance()->clearDateRange();
     m_browser->reload();
     reloadThumbnails(ThumbnailView::MaintainSelection);
 }
 
 void MainWindow::Window::showThumbNails(const DB::FileNameList &items)
 {
     m_thumbnailView->setImageList(items);
     m_statusBar->mp_partial->setMatchCount(items.size());
     showThumbNails();
 }
 
 void MainWindow::Window::slotRecalcCheckSums()
 {
     DB::ImageDB::instance()->slotRecalcCheckSums(selected());
 }
 
 void MainWindow::Window::slotShowExifInfo()
 {
     DB::FileNameList items = selectedOnDisk();
     if (!items.isEmpty()) {
         Exif::InfoDialog *exifDialog = new Exif::InfoDialog(items.at(0), this);
         exifDialog->show();
     }
 }
 
 void MainWindow::Window::showFeatures()
 {
     FeatureDialog dialog(this);
     dialog.exec();
 }
 
 void MainWindow::Window::showImage(const DB::FileName &fileName)
 {
     launchViewer(DB::FileNameList() << fileName, true, false, false);
 }
 
 void MainWindow::Window::slotBuildThumbnails()
 {
     ImageManager::ThumbnailBuilder::instance()->buildAll(ImageManager::StartNow);
 }
 
 void MainWindow::Window::slotBuildThumbnailsIfWanted()
 {
     ImageManager::ThumbnailCache::instance()->flush();
     if (!Settings::SettingsData::instance()->incrementalThumbnails())
         ImageManager::ThumbnailBuilder::instance()->buildAll(ImageManager::StartDelayed);
 }
 
 void MainWindow::Window::slotOrderIncr()
 {
     m_thumbnailView->setSortDirection(ThumbnailView::OldestFirst);
 }
 
 void MainWindow::Window::slotOrderDecr()
 {
     m_thumbnailView->setSortDirection(ThumbnailView::NewestFirst);
 }
 
 void MainWindow::Window::showVideos()
 {
     QDesktopServices::openUrl(QUrl(
         QStringLiteral("https://www.kphotoalbum.org/documentation/videos/")));
 }
 
 void MainWindow::Window::slotStatistics()
 {
     static StatisticsDialog *dialog = new StatisticsDialog(this);
     dialog->show();
 }
 
 void MainWindow::Window::slotMarkUntagged()
 {
     if (Settings::SettingsData::instance()->hasUntaggedCategoryFeatureConfigured()) {
         for (const DB::FileName &newFile : selected()) {
             newFile.info()->addCategoryInfo(Settings::SettingsData::instance()->untaggedCategory(),
                                             Settings::SettingsData::instance()->untaggedTag());
         }
 
         DirtyIndicator::markDirty();
     } else {
         // Note: the same dialog text is used in
         // Browser::OverviewPage::activateUntaggedImagesAction(),
         // so if it is changed, be sure to also change it there!
         KMessageBox::information(this,
                                  i18n("<p>You have not yet configured which tag to use for indicating untagged images."
                                       "</p>"
                                       "<p>Please follow these steps to do so:"
                                       "<ul><li>In the menu bar choose <b>Settings</b></li>"
                                       "<li>From there choose <b>Configure KPhotoAlbum</b></li>"
                                       "<li>Now choose the <b>Categories</b> icon</li>"
                                       "<li>Now configure section <b>Untagged Images</b></li></ul></p>"),
                                  i18n("Feature has not been configured"));
     }
 }
 
 void MainWindow::Window::setupStatusBar()
 {
     m_statusBar = new MainWindow::StatusBar;
     setStatusBar(m_statusBar);
     setLocked(Settings::SettingsData::instance()->locked(), true, false);
     connect(m_statusBar, &StatusBar::thumbnailSettingsRequested, [this]() { this->slotOptions(); m_settingsDialog->activatePage(Settings::SettingsPage::ThumbnailsPage); });
 }
 
 void MainWindow::Window::slotRecreateExifDB()
 {
     Exif::Database::instance()->recreate();
 }
 
 void MainWindow::Window::useNextVideoThumbnail()
 {
     UpdateVideoThumbnail::useNext(selected());
 }
 
 void MainWindow::Window::usePreviousVideoThumbnail()
 {
     UpdateVideoThumbnail::usePrevious(selected());
 }
 
 void MainWindow::Window::mergeDuplicates()
 {
     DuplicateMerger *merger = new DuplicateMerger;
     merger->show();
 }
 
 void MainWindow::Window::slotThumbnailSizeChanged()
 {
     QString thumbnailSizeMsg = i18nc("@info:status",
                                      //xgettext:no-c-format
                                      "Thumbnail width: %1px (storage size: %2px)",
                                      Settings::SettingsData::instance()->actualThumbnailSize(),
                                      Settings::SettingsData::instance()->thumbnailSize());
     m_statusBar->showMessage(thumbnailSizeMsg, 4000);
 }
 
 void MainWindow::Window::createSearchBar()
 {
     // Set up the search tool bar
     SearchBar *searchBar = new SearchBar(this);
     searchBar->setLineEditEnabled(false);
     searchBar->setObjectName(QString::fromUtf8("searchBar"));
 
     connect(searchBar, &SearchBar::textChanged, m_browser, &Browser::BrowserWidget::slotLimitToMatch);
     connect(searchBar, &SearchBar::returnPressed, m_browser, &Browser::BrowserWidget::slotInvokeSeleted);
     connect(searchBar, &SearchBar::keyPressed, m_browser, &Browser::BrowserWidget::scrollKeyPressed);
     connect(m_browser, &Browser::BrowserWidget::viewChanged, searchBar, &SearchBar::reset);
     connect(m_browser, &Browser::BrowserWidget::isSearchable, searchBar, &SearchBar::setLineEditEnabled);
     QAction *toggleSearchBar = actionCollection()->action(QString::fromLatin1("toggleSearchBar"));
     Q_ASSERT(toggleSearchBar);
     connect(toggleSearchBar, &QAction::triggered, searchBar, &SearchBar::setVisible);
     connect(searchBar, &SearchBar::visibilityChanged, toggleSearchBar, &QAction::setChecked);
 
     auto filterWidget = m_thumbnailView->filterWidget();
     addToolBar(filterWidget);
     filterWidget->setObjectName(QString::fromUtf8("filterBar"));
     connect(m_browser, &Browser::BrowserWidget::viewChanged, ThumbnailView::ThumbnailFacade::instance(), &ThumbnailView::ThumbnailFacade::clearFilter);
     connect(m_browser, &Browser::BrowserWidget::isFilterable, filterWidget, &ThumbnailView::FilterWidget::setEnabled);
     QAction *toggleFilterToolbar = actionCollection()->action(QString::fromLatin1("toggleFilterToolbar"));
     Q_ASSERT(toggleFilterToolbar);
     connect(toggleFilterToolbar, &QAction::triggered, filterWidget, &ThumbnailView::FilterWidget::setVisible);
     connect(filterWidget, &ThumbnailView::FilterWidget::visibilityChanged, toggleFilterToolbar, &QAction::setChecked);
 }
 
 void MainWindow::Window::executeStartupActions()
 {
     new ImageManager::ThumbnailBuilder(m_statusBar, this);
     if (!Settings::SettingsData::instance()->incrementalThumbnails())
         ImageManager::ThumbnailBuilder::instance()->buildMissing();
     connect(Settings::SettingsData::instance(), &Settings::SettingsData::thumbnailSizeChanged,
             this, &Window::slotBuildThumbnailsIfWanted);
 
     if (!FeatureDialog::hasVideoThumbnailer()) {
         BackgroundTaskManager::JobManager::instance()->addJob(
             new BackgroundJobs::SearchForVideosWithoutLengthInfo);
 
         BackgroundTaskManager::JobManager::instance()->addJob(
             new BackgroundJobs::SearchForVideosWithoutVideoThumbnailsJob);
     }
 }
 
 void MainWindow::Window::checkIfVideoThumbnailerIsInstalled()
 {
     if (Options::the()->demoMode())
         return;
 
     if (!FeatureDialog::hasVideoThumbnailer()) {
         KMessageBox::information(this,
                                  i18n("<p>Unable to find ffmpeg on the system.</p>"
                                       "<p>Without it, KPhotoAlbum will not be able to display video thumbnails and video lengths. "
                                       "Please install the ffmpeg package</p>"),
                                  i18n("Video thumbnails are not available"), QString::fromLatin1("VideoThumbnailerNotInstalled"));
     }
 }
 
 bool MainWindow::Window::anyVideosSelected() const
 {
     const auto selectedFiles = selected();
     for (const DB::FileName &fileName : selectedFiles) {
         if (Utilities::isVideo(fileName))
             return true;
     }
     return false;
 }
 
 void MainWindow::Window::setHistogramVisibilty(bool visible) const
 {
     if (visible) {
         m_dateBar->show();
         m_dateBarLine->show();
     } else {
         m_dateBar->hide();
         m_dateBarLine->hide();
     }
 }
 
 void MainWindow::Window::slotImageRotated(const DB::FileName &fileName)
 {
     // An image has been rotated by the annotation dialog or the viewer.
     // We have to reload the respective thumbnail to get it in the right angle
     ImageManager::ThumbnailCache::instance()->removeThumbnail(fileName);
 }
 
 bool MainWindow::Window::dbIsDirty() const
 {
     return m_statusBar->mp_dirtyIndicator->isSaveDirty();
 }
 
 #ifdef HAVE_MARBLE
 void MainWindow::Window::showPositionBrowser()
 {
     auto positionBrowser = positionBrowserWidget();
     m_stack->setCurrentWidget(positionBrowser);
     updateStates(false);
 }
 
 Map::MapView *MainWindow::Window::positionBrowserWidget()
 {
     if (!m_positionBrowser) {
         m_positionBrowser = new Map::MapView(m_stack, Map::UsageType::InlineMapView);
         m_stack->addWidget(m_positionBrowser);
     }
     return m_positionBrowser;
 }
 #endif
 
 UserFeedback MainWindow::Window::askWarningContinueCancel(const QString &msg, const QString &title, const QString &dialogId)
 {
     auto answer = KMessageBox::warningContinueCancel(this, msg, title, KStandardGuiItem::cont(), KStandardGuiItem::cancel(), dialogId);
     return (answer == KMessageBox::Continue) ? UserFeedback::Confirm : UserFeedback::Deny;
 }
 
 UserFeedback MainWindow::Window::askQuestionYesNo(const QString &msg, const QString &title, const QString &dialogId)
 {
     auto answer = KMessageBox::questionYesNo(this, msg, title, KStandardGuiItem::yes(), KStandardGuiItem::no(), dialogId);
     return (answer == KMessageBox::Yes) ? UserFeedback::Confirm : UserFeedback::Deny;
 }
 
 void MainWindow::Window::showInformation(const QString &msg, const QString &title, const QString &dialogId)
 {
     KMessageBox::information(this, msg, title, dialogId);
 }
 
 void MainWindow::Window::showSorry(const QString &msg, const QString &title, const QString &)
 {
     KMessageBox::sorry(this, msg, title);
 }
 
 void MainWindow::Window::showError(const QString &msg, const QString &title, const QString &)
 {
     KMessageBox::error(this, msg, title);
 }
 
 bool MainWindow::Window::isDialogDisabled(const QString &dialogId)
 {
     // Note(jzarl): there are different methods for different kinds of dialogs.
     // However, all these methods share exactly the same code in KMessageBox.
     // If that ever changes, we can still update our implementation - until then I won't just copy a stupid API...
     return !KMessageBox::shouldBeShownContinue(dialogId);
 }
 
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/MainWindow/Window.h b/MainWindow/Window.h
index ab00ad77..e643ebeb 100644
--- a/MainWindow/Window.h
+++ b/MainWindow/Window.h
@@ -1,311 +1,312 @@
-/* Copyright (C) 2003-2019 The KPhotoAlbum Development Team
+/* Copyright (C) 2003-2020 The KPhotoAlbum Development Team
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef MAINWINDOW_WINDOW_H
 #define MAINWINDOW_WINDOW_H
 #include <DB/Category.h>
 #include <DB/FileNameList.h>
 #include <DB/ImageSearchInfo.h>
 #include <DB/UIDelegate.h>
 #include <ThumbnailView/enums.h>
 #include <config-kpa-marble.h>
 
 #include <KXmlGuiWindow>
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 #include <config-kpa-kipi.h>
 
 class QAction;
 class QCloseEvent;
 class QContextMenuEvent;
 class QFrame;
 class QLabel;
 class QMoveEvent;
 class QResizeEvent;
 class QStackedWidget;
 class QTimer;
 
 class KActionMenu;
 class KTipDialog;
 class KToggleAction;
 
 #ifdef HASKIPI
 namespace KIPI
 {
 class PluginLoader;
 }
 #endif
 #ifdef HAVE_MARBLE
 namespace Map
 {
 class MapView;
 }
 #endif
 
 namespace AnnotationDialog
 {
 class Dialog;
 }
 namespace Browser
 {
 class BrowserWidget;
 class BreadcrumbList;
 }
 namespace DateBar
 {
 class DateBarWidget;
 }
 namespace DB
 {
 class ImageInfoList;
 }
 namespace HTMLGenerator
 {
 class HTMLDialog;
 }
 namespace Plugins
 {
 class Interface;
 }
 namespace Settings
 {
 class SettingsDialog;
 }
 namespace ThumbnailView
 {
 class ThumbnailFacade;
 }
 
 class BreadcrumbViewer;
 
 namespace MainWindow
 {
 class DeleteDialog;
 class StatusBar;
 class TokenEditor;
 
 class Window : public KXmlGuiWindow, public DB::UIDelegate
 {
     Q_OBJECT
 
 public:
     explicit Window(QWidget *parent);
     ~Window() override;
     static void configureImages(const DB::ImageInfoList &list, bool oneAtATime);
     static Window *theMainWindow();
     DB::FileNameList selected(ThumbnailView::SelectionMode mode = ThumbnailView::ExpandCollapsedStacks) const;
     DB::ImageSearchInfo currentContext();
     QString currentBrowseCategory() const;
     void setStackHead(const DB::FileName &image);
     void setHistogramVisibilty(bool visible) const;
     bool dbIsDirty() const;
 #ifdef HAVE_MARBLE
     void showPositionBrowser();
     Map::MapView *positionBrowserWidget();
 #endif
 
     // implement UI delegate interface
     // Note(jzarl): we just could create a UIDelegate class that takes a QWidget,
     // implementing the same messageParent approach that we took before.
     // For now, I don't see anything wrong with directly implementing the interface instead.
     // I may change my mind later and I'm ready to convinced of the errors of my way, though...
     DB::UserFeedback askWarningContinueCancel(const QString &msg, const QString &title, const QString &dialogId) override;
     DB::UserFeedback askQuestionYesNo(const QString &msg, const QString &title, const QString &dialogId) override;
     void showInformation(const QString &msg, const QString &title, const QString &dialogId) override;
     void showSorry(const QString &msg, const QString &title, const QString &) override;
     void showError(const QString &msg, const QString &title, const QString &) override;
     bool isDialogDisabled(const QString &dialogId) override;
 
 public slots:
     void showThumbNails(const DB::FileNameList &items);
     void loadKipiPlugins();
     void reloadThumbnails(ThumbnailView::SelectionUpdateMethod method = ThumbnailView::MaintainSelection);
     void runDemo();
     void slotImageRotated(const DB::FileName &fileName);
     void slotSave();
 
 protected slots:
     void showThumbNails();
     bool slotExit();
     void slotOptions();
     void slotConfigureAllImages();
     void slotConfigureImagesOneAtATime();
     void slotCreateImageStack();
     void slotUnStackImages();
     void slotSetStackHead();
     void slotCopySelectedURLs();
     void slotPasteInformation();
     void slotDeleteSelected();
     void slotReReadExifInfo();
     void slotAutoStackImages();
     void slotSearch();
     // FIXME(jzarl): improve this function signature:
     void slotView(bool reuse, bool slideShow = false, bool random = false);
     void slotView();
     void slotViewNewWindow();
     void slotSortByDateAndTime();
     void slotSortAllByDateAndTime();
     void slotLimitToSelected();
     void slotExportToHTML();
     void slotAutoSave();
     void showBrowser();
     void slotOptionGroupChanged();
     void showTipOfDay();
     void lockToDefaultScope();
     void setDefaultScopePositive();
     void setDefaultScopeNegative();
     void unlockFromDefaultScope();
     void changePassword();
     void slotConfigureKeyBindings();
     void slotSetFileName(const DB::FileName &);
     void updateContextMenuFromSelectionSize(int selectionSize);
     void slotUpdateViewMenu(DB::Category::ViewType);
     void slotShowNotOnDisk();
     void slotBuildThumbnails();
     void slotBuildThumbnailsIfWanted();
     void slotRunSlideShow();
     void slotRunRandomizedSlideShow();
     void slotConfigureToolbars();
     void slotNewToolbarConfig();
     void slotImport();
     void slotExport();
     void delayedInit();
     void slotReenableMessages();
     void slotImagesChanged(const QList<QUrl> &);
     void slotSelectionChanged(int count);
     void plug();
     void slotRemoveTokens();
     void slotShowListOfFiles();
     void updateDateBar(const Browser::BreadcrumbList &);
     void updateDateBar();
     void slotShowImagesWithInvalidDate();
     void slotShowImagesWithChangedMD5Sum();
     void showDateBarTip(const QString &);
     void slotJumpToContext();
     void setDateRange(const DB::ImageDate &);
     void clearDateRange();
     void startAutoSaveTimer();
     void slotRecalcCheckSums();
     void slotShowExifInfo();
     void showFeatures();
     void showImage(const DB::FileName &fileName);
     void slotOrderIncr();
     void slotOrderDecr();
     void slotRotateSelectedLeft();
     void slotRotateSelectedRight();
     void rotateSelected(int angle);
     void showVideos();
     void slotStatistics();
     void slotRecreateExifDB();
     void useNextVideoThumbnail();
     void usePreviousVideoThumbnail();
     void mergeDuplicates();
     void slotThumbnailSizeChanged();
     void slotMarkUntagged();
 
 protected:
     void configureImages(bool oneAtATime);
     QString welcome();
     void closeEvent(QCloseEvent *e) override;
     void resizeEvent(QResizeEvent *) override;
     void moveEvent(QMoveEvent *) override;
     void setupMenuBar();
     void createAnnotationDialog();
     bool load();
     void contextMenuEvent(QContextMenuEvent *e) override;
     void setLocked(bool b, bool force, bool recount = true);
     void configImages(const DB::ImageInfoList &list, bool oneAtATime);
     void updateStates(bool thumbNailView);
     DB::FileNameList selectedOnDisk();
     void setupPluginMenu();
     void launchViewer(const DB::FileNameList &mediaList, bool reuse, bool slideShow, bool random);
     void setupStatusBar();
     void setPluginMenuState(const char *name, const QList<QAction *> &actions);
     void createSearchBar();
     void executeStartupActions();
     void checkIfVideoThumbnailerIsInstalled();
     bool anyVideosSelected() const;
 
 private:
     static Window *s_instance;
 
     ThumbnailView::ThumbnailFacade *m_thumbnailView;
     Settings::SettingsDialog *m_settingsDialog;
     QPointer<AnnotationDialog::Dialog> m_annotationDialog;
     QStackedWidget *m_stack;
     QTimer *m_autoSaveTimer;
     Browser::BrowserWidget *m_browser;
     DeleteDialog *m_deleteDialog;
     QAction *m_lock;
     QAction *m_unlock;
     QAction *m_setDefaultPos;
     QAction *m_setDefaultNeg;
     QAction *m_jumpToContext;
     HTMLGenerator::HTMLDialog *m_htmlDialog;
     QAction *m_configOneAtATime;
     QAction *m_configAllSimultaniously;
     QAction *m_createImageStack;
     QAction *m_unStackImages;
     QAction *m_setStackHead;
     QAction *m_view;
     QAction *m_rotLeft;
     QAction *m_rotRight;
     QAction *m_sortByDateAndTime;
     QAction *m_sortAllByDateAndTime;
     QAction *m_AutoStackImages;
     QAction *m_viewInNewWindow;
     KActionMenu *m_viewMenu;
     KToggleAction *m_smallListView;
     KToggleAction *m_largeListView;
     KToggleAction *m_largeIconView;
+    KActionMenu *m_colorSchemeMenu;
     QAction *m_generateHtml;
     QAction *m_copy;
     QAction *m_paste;
     QAction *m_deleteSelected;
     QAction *m_limitToMarked;
     QAction *m_selectAll;
     QAction *m_clearSelection;
     QAction *m_runSlideShow;
     QAction *m_runRandomSlideShow;
     Plugins::Interface *m_pluginInterface;
     QAction *m_showExifDialog;
 #ifdef HASKIPI
     KIPI::PluginLoader *m_pluginLoader;
 #endif
     QAction *m_recreateThumbnails;
     QAction *m_useNextVideoThumbnail;
     QAction *m_usePreviousVideoThumbnail;
     QAction *m_markUntagged;
     TokenEditor *m_tokenEditor;
     DateBar::DateBarWidget *m_dateBar;
     QFrame *m_dateBarLine;
     bool m_hasLoadedKipiPlugins;
     QMap<Qt::Key, QPair<QString, QString>> m_viewerInputMacros;
     MainWindow::StatusBar *m_statusBar;
     QString m_lastTarget;
 #ifdef HAVE_MARBLE
     Map::MapView *m_positionBrowser;
 #endif
 };
 
 }
 
 #endif /* MAINWINDOW_WINDOW_H */
 
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/Settings/SettingsData.cpp b/Settings/SettingsData.cpp
index 7cc4d7b4..b0690c12 100644
--- a/Settings/SettingsData.cpp
+++ b/Settings/SettingsData.cpp
@@ -1,614 +1,615 @@
-/* Copyright (C) 2003-2019 The KPhotoAlbum Development Team
+/* Copyright (C) 2003-2020 The KPhotoAlbum Development Team
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e. V. (or its successor approved
    by the membership of KDE e. V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "SettingsData.h"
 
 #include <DB/CategoryCollection.h>
 #include <DB/ImageDB.h>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <QApplication>
 #include <QPixmapCache>
 #include <QStringList>
 #include <QThread>
 #include <stdlib.h>
 
 #define STR(x) QString::fromLatin1(x)
 
 #define value(GROUP, OPTION, DEFAULT) \
     KSharedConfig::openConfig()->group(GROUP).readEntry(OPTION, DEFAULT)
 
 #define setValue(GROUP, OPTION, VALUE)                                  \
     {                                                                   \
         KConfigGroup group = KSharedConfig::openConfig()->group(GROUP); \
         group.writeEntry(OPTION, VALUE);                                \
         group.sync();                                                   \
     }
 
 #define getValueFunc_(TYPE, FUNC, GROUP, OPTION, DEFAULT) \
     TYPE SettingsData::FUNC() const                       \
     {                                                     \
         return (TYPE)value(GROUP, OPTION, DEFAULT);       \
     }
 
 #define setValueFunc_(FUNC, TYPE, GROUP, OPTION, VALUE) \
     void SettingsData::FUNC(const TYPE v)               \
     {                                                   \
         setValue(GROUP, OPTION, VALUE);                 \
     }
 
 #define getValueFunc(TYPE, FUNC, GROUP, DEFAULT) getValueFunc_(TYPE, FUNC, #GROUP, #FUNC, DEFAULT)
 #define setValueFunc(FUNC, TYPE, GROUP, OPTION) setValueFunc_(FUNC, TYPE, #GROUP, #OPTION, v)
 
 // TODO(mfwitten): document parameters.
 #define property_(GET_TYPE, GET_FUNC, GET_VALUE, SET_FUNC, SET_TYPE, SET_VALUE, GROUP, OPTION, GET_DEFAULT_1, GET_DEFAULT_2, GET_DEFAULT_2_TYPE) \
     GET_TYPE SettingsData::GET_FUNC() const                                                                                                      \
     {                                                                                                                                            \
         KConfigGroup g = KSharedConfig::openConfig()->group(GROUP);                                                                              \
                                                                                                                                                  \
         if (!g.hasKey(OPTION))                                                                                                                   \
             return GET_DEFAULT_1;                                                                                                                \
                                                                                                                                                  \
         GET_DEFAULT_2_TYPE v = g.readEntry(OPTION, (GET_DEFAULT_2_TYPE)GET_DEFAULT_2);                                                           \
         return (GET_TYPE)GET_VALUE;                                                                                                              \
     }                                                                                                                                            \
     setValueFunc_(SET_FUNC, SET_TYPE, GROUP, OPTION, SET_VALUE)
 
 #define property(GET_TYPE, GET_FUNC, SET_FUNC, SET_TYPE, SET_VALUE, GROUP, OPTION, GET_DEFAULT) \
     getValueFunc_(GET_TYPE, GET_FUNC, GROUP, OPTION, GET_DEFAULT)                               \
         setValueFunc_(SET_FUNC, SET_TYPE, GROUP, OPTION, SET_VALUE)
 
 #define property_copy(GET_FUNC, SET_FUNC, TYPE, GROUP, GET_DEFAULT) \
     property(TYPE, GET_FUNC, SET_FUNC, TYPE, v, #GROUP, #GET_FUNC, GET_DEFAULT)
 
 #define property_ref_(GET_FUNC, SET_FUNC, TYPE, GROUP, GET_DEFAULT) \
     property(TYPE, GET_FUNC, SET_FUNC, TYPE &, v, GROUP, #GET_FUNC, GET_DEFAULT)
 
 #define property_ref(GET_FUNC, SET_FUNC, TYPE, GROUP, GET_DEFAULT) \
     property(TYPE, GET_FUNC, SET_FUNC, TYPE &, v, #GROUP, #GET_FUNC, GET_DEFAULT)
 
 #define property_enum(GET_FUNC, SET_FUNC, TYPE, GROUP, GET_DEFAULT) \
     property(TYPE, GET_FUNC, SET_FUNC, TYPE, (int)v, #GROUP, #GET_FUNC, (int)GET_DEFAULT)
 
 #define property_sset(GET_FUNC, SET_FUNC, GROUP, GET_DEFAULT) \
     property_(StringSet, GET_FUNC, v.toSet(), SET_FUNC, StringSet &, v.toList(), #GROUP, #GET_FUNC, GET_DEFAULT, QStringList(), QStringList)
 
 /**
  * smoothScale() is called from the image loading thread, therefore we need
  * to cache it this way, rather than going to KConfig.
  */
 static bool _smoothScale = true;
 
 using namespace Settings;
 
 const WindowType Settings::MainWindow = "MainWindow";
 const WindowType Settings::AnnotationDialog = "AnnotationDialog";
 
 SettingsData *SettingsData::s_instance = nullptr;
 
 SettingsData *SettingsData::instance()
 {
     if (!s_instance)
         qFatal("instance called before loading a setup!");
 
     return s_instance;
 }
 
 bool SettingsData::ready()
 {
     return s_instance;
 }
 
 void SettingsData::setup(const QString &imageDirectory)
 {
     if (!s_instance)
         s_instance = new SettingsData(imageDirectory);
 }
 
 SettingsData::SettingsData(const QString &imageDirectory)
 {
     m_hasAskedAboutTimeStamps = false;
 
     QString s = STR("/");
     m_imageDirectory = imageDirectory.endsWith(s) ? imageDirectory : imageDirectory + s;
 
     _smoothScale = value("Viewer", "smoothScale", true);
 
     // Split the list of Exif comments that should be stripped automatically to a list
 
     QStringList commentsToStrip = value("General", "commentsToStrip", QString::fromLatin1("Exif_JPEG_PICTURE-,-OLYMPUS DIGITAL CAMERA-,-JENOPTIK DIGITAL CAMERA-,-")).split(QString::fromLatin1("-,-"), QString::SkipEmptyParts);
     for (QString &comment : commentsToStrip)
         comment.replace(QString::fromLatin1(",,"), QString::fromLatin1(","));
 
     m_EXIFCommentsToStrip = commentsToStrip;
 }
 
 /////////////////
 //// General ////
 /////////////////
 
 // clang-format off
 property_copy(useEXIFRotate, setUseEXIFRotate, bool, General, true)
 property_copy(useEXIFComments, setUseEXIFComments, bool, General, true)
 property_copy(stripEXIFComments, setStripEXIFComments, bool, General, true)
 property_copy(commentsToStrip, setCommentsToStrip, QString, General, "" /* see constructor */)
 property_copy(searchForImagesOnStart, setSearchForImagesOnStart, bool, General, true)
 property_copy(ignoreFileExtension, setIgnoreFileExtension, bool, General, false)
 property_copy(skipSymlinks, setSkipSymlinks, bool, General, false)
 property_copy(skipRawIfOtherMatches, setSkipRawIfOtherMatches, bool, General, false)
 property_copy(useRawThumbnail, setUseRawThumbnail, bool, General, true)
 property_copy(useRawThumbnailSize, setUseRawThumbnailSize, QSize, General, QSize(1024, 768))
 property_copy(useCompressedIndexXML, setUseCompressedIndexXML, bool, General, true)
 property_copy(compressBackup, setCompressBackup, bool, General, true)
 property_copy(showSplashScreen, setShowSplashScreen, bool, General, true)
 property_copy(showHistogram, setShowHistogram, bool, General, true)
 property_copy(autoSave, setAutoSave, int, General, 5)
 property_copy(backupCount, setBackupCount, int, General, 5)
 property_enum(tTimeStamps, setTTimeStamps, TimeStampTrust, General, Always)
 property_copy(excludeDirectories, setExcludeDirectories, QString, General, QString::fromLatin1("xml,ThumbNails,.thumbs"))
 #ifdef KPA_ENABLE_REMOTECONTROL
 property_copy(recentAndroidAddress, setRecentAndroidAddress, QString, General, QString())
 property_copy(listenForAndroidDevicesOnStartup, setListenForAndroidDevicesOnStartup, bool, General, false)
 #endif
+property_copy(colorScheme, setColorScheme, QString, General, QString());
 
 getValueFunc(QSize, histogramSize, General, QSize(15, 30))
 getValueFunc(ViewSortType, viewSortType, General, (int)SortLastUse)
 getValueFunc(AnnotationDialog::MatchType, matchType, General, (int)AnnotationDialog::MatchFromWordStart)
 getValueFunc(bool, histogramUseLinearScale, General, false)
 
     // clang-format on
     void SettingsData::setHistogramUseLinearScale(const bool useLinearScale)
 {
     if (useLinearScale == histogramUseLinearScale())
         return;
 
     setValue("General", "histogramUseLinearScale", useLinearScale);
     emit histogramScaleChanged();
 }
 
 void SettingsData::setHistogramSize(const QSize &size)
 {
     if (size == histogramSize())
         return;
 
     setValue("General", "histogramSize", size);
     emit histogramSizeChanged(size);
 }
 
 void SettingsData::setViewSortType(const ViewSortType tp)
 {
     if (tp == viewSortType())
         return;
 
     setValue("General", "viewSortType", (int)tp);
     emit viewSortTypeChanged(tp);
 }
 void SettingsData::setMatchType(const AnnotationDialog::MatchType mt)
 {
     if (mt == matchType())
         return;
 
     setValue("General", "matchType", (int)mt);
     emit matchTypeChanged(mt);
 }
 
 bool SettingsData::trustTimeStamps()
 {
     if (tTimeStamps() == Always)
         return true;
     else if (tTimeStamps() == Never)
         return false;
     else {
         if (!m_hasAskedAboutTimeStamps) {
             QApplication::setOverrideCursor(Qt::ArrowCursor);
             QString txt = i18n("When reading time information of images, their Exif info is used. "
                                "Exif info may, however, not be supported by your KPhotoAlbum installation, "
                                "or no valid information may be in the file. "
                                "As a backup, KPhotoAlbum may use the timestamp of the image - this may, "
                                "however, not be valid in case the image is scanned in. "
                                "So the question is, should KPhotoAlbum trust the time stamp on your images?");
             int answer = KMessageBox::questionYesNo(nullptr, txt, i18n("Trust Time Stamps?"));
             QApplication::restoreOverrideCursor();
             if (answer == KMessageBox::Yes)
                 m_trustTimeStamps = true;
             else
                 m_trustTimeStamps = false;
             m_hasAskedAboutTimeStamps = true;
         }
         return m_trustTimeStamps;
     }
 }
 
 ////////////////////////////////
 //// File Version Detection ////
 ////////////////////////////////
 
 // clang-format off
 property_copy(detectModifiedFiles, setDetectModifiedFiles, bool, FileVersionDetection, true)
 property_copy(modifiedFileComponent, setModifiedFileComponent, QString, FileVersionDetection, "^(.*)-edited.([^.]+)$")
 property_copy(originalFileComponent, setOriginalFileComponent, QString, FileVersionDetection, "\\1.\\2")
 property_copy(moveOriginalContents, setMoveOriginalContents, bool, FileVersionDetection, false)
 property_copy(autoStackNewFiles, setAutoStackNewFiles, bool, FileVersionDetection, true)
 property_copy(copyFileComponent, setCopyFileComponent, QString, FileVersionDetection, "(.[^.]+)$")
 property_copy(copyFileReplacementComponent, setCopyFileReplacementComponent, QString, FileVersionDetection, "-edited\\1")
 property_copy(loadOptimizationPreset, setLoadOptimizationPreset, int, FileVersionDetection, 0)
 property_copy(overlapLoadMD5, setOverlapLoadMD5, bool, FileVersionDetection, false)
 property_copy(preloadThreadCount, setPreloadThreadCount, int, FileVersionDetection, 1)
 property_copy(thumbnailPreloadThreadCount, setThumbnailPreloadThreadCount, int, FileVersionDetection, 1)
 property_copy(thumbnailBuilderThreadCount, setThumbnailBuilderThreadCount, int, FileVersionDetection, 0)
     // clang-format on
 
     ////////////////////
     //// Thumbnails ////
     ////////////////////
 
     // clang-format off
 property_copy(displayLabels, setDisplayLabels, bool, Thumbnails, true)
 property_copy(displayCategories, setDisplayCategories, bool, Thumbnails, false)
 property_copy(autoShowThumbnailView, setAutoShowThumbnailView, int, Thumbnails, 20)
 property_copy(showNewestThumbnailFirst, setShowNewestFirst, bool, Thumbnails, false)
 property_copy(thumbnailDisplayGrid, setThumbnailDisplayGrid, bool, Thumbnails, false)
 property_copy(previewSize, setPreviewSize, int, Thumbnails, 256)
 property_copy(thumbnailSpace, setThumbnailSpace, int, Thumbnails, 4)
 // not available via GUI, but should be consistent (and maybe confgurable for powerusers):
 property_copy(minimumThumbnailSize, setMinimumThumbnailSize, int, Thumbnails, 32)
 property_copy(maximumThumbnailSize, setMaximumThumbnailSize, int, Thumbnails, 4096)
 property_enum(thumbnailAspectRatio, setThumbnailAspectRatio, ThumbnailAspectRatio, Thumbnails, Aspect_3_2)
 property_ref(backgroundColor, setBackgroundColor, QString, Thumbnails, QColor(Qt::darkGray).name())
 property_copy(incrementalThumbnails, setIncrementalThumbnails, bool, Thumbnails, true)
 
 // database specific so that changing it doesn't invalidate the thumbnail cache for other databases:
 getValueFunc_(int, thumbnailSize, groupForDatabase("Thumbnails"), "thumbSize", 256)
     // clang-format on
 
     void SettingsData::setThumbnailSize(int value)
 {
     // enforce limits:
     value = qBound(minimumThumbnailSize(), value, maximumThumbnailSize());
 
     if (value != thumbnailSize())
         emit thumbnailSizeChanged(value);
     setValue(groupForDatabase("Thumbnails"), "thumbSize", value);
 }
 
 int SettingsData::actualThumbnailSize() const
 {
     // this is database specific since it's a derived value of thumbnailSize
     int retval = value(groupForDatabase("Thumbnails"), "actualThumbSize", 0);
     // if no value has been set, use thumbnailSize
     if (retval == 0)
         retval = thumbnailSize();
     return retval;
 }
 
 void SettingsData::setActualThumbnailSize(int value)
 {
     QPixmapCache::clear();
 
     // enforce limits:
     value = qBound(minimumThumbnailSize(), value, thumbnailSize());
 
     if (value != actualThumbnailSize()) {
         setValue(groupForDatabase("Thumbnails"), "actualThumbSize", value);
         emit actualThumbnailSizeChanged(value);
     }
 }
 
 ////////////////
 //// Viewer ////
 ////////////////
 
 // clang-format off
 property_ref(viewerSize, setViewerSize, QSize, Viewer, QSize(1024, 768))
 property_ref(slideShowSize, setSlideShowSize, QSize, Viewer, QSize(1024, 768))
 property_copy(launchViewerFullScreen, setLaunchViewerFullScreen, bool, Viewer, false)
 property_copy(launchSlideShowFullScreen, setLaunchSlideShowFullScreen, bool, Viewer, true)
 property_copy(showInfoBox, setShowInfoBox, bool, Viewer, true)
 property_copy(showLabel, setShowLabel, bool, Viewer, true)
 property_copy(showDescription, setShowDescription, bool, Viewer, true)
 property_copy(showDate, setShowDate, bool, Viewer, true)
 property_copy(showImageSize, setShowImageSize, bool, Viewer, true)
 property_copy(showRating, setShowRating, bool, Viewer, true)
 property_copy(showTime, setShowTime, bool, Viewer, true)
 property_copy(showFilename, setShowFilename, bool, Viewer, false)
 property_copy(showEXIF, setShowEXIF, bool, Viewer, true)
 property_copy(slideShowInterval, setSlideShowInterval, int, Viewer, 5)
 property_copy(viewerCacheSize, setViewerCacheSize, int, Viewer, 195)
 property_copy(infoBoxWidth, setInfoBoxWidth, int, Viewer, 400)
 property_copy(infoBoxHeight, setInfoBoxHeight, int, Viewer, 300)
 property_enum(infoBoxPosition, setInfoBoxPosition, Position, Viewer, Bottom)
 property_enum(viewerStandardSize, setViewerStandardSize, StandardViewSize, Viewer, FullSize)
     // clang-format on
 
     bool SettingsData::smoothScale() const
 {
     return _smoothScale;
 }
 
 void SettingsData::setSmoothScale(bool b)
 {
     _smoothScale = b;
     setValue("Viewer", "smoothScale", b);
 }
 
 ////////////////////
 //// Categories ////
 ////////////////////
 
 setValueFunc(setAlbumCategory, QString &, General, albumCategory)
 
     QString SettingsData::albumCategory() const
 {
     QString category = value("General", "albumCategory", STR(""));
 
     if (!DB::ImageDB::instance()->categoryCollection()->categoryNames().contains(category)) {
         category = DB::ImageDB::instance()->categoryCollection()->categoryNames()[0];
         const_cast<SettingsData *>(this)->setAlbumCategory(category);
     }
 
     return category;
 }
 
 // clang-format off
 property_ref(untaggedCategory, setUntaggedCategory, QString, General, i18n("Events"))
 property_ref(untaggedTag, setUntaggedTag, QString, General, i18n("untagged"))
 property_copy(untaggedImagesTagVisible, setUntaggedImagesTagVisible, bool, General, false)
     // clang-format on
 
     //////////////
     //// Exif ////
     //////////////
 
     // clang-format off
 property_sset(exifForViewer, setExifForViewer, Exif, StringSet())
 property_sset(exifForDialog, setExifForDialog, Exif, Exif::Info::instance()->standardKeys())
 property_ref(iptcCharset, setIptcCharset, QString, Exif, QString())
     // clang-format on
 
     /////////////////////
     //// Exif Import ////
     /////////////////////
 
     // clang-format off
 property_copy(updateExifData, setUpdateExifData, bool, ExifImport, true)
 property_copy(updateImageDate, setUpdateImageDate, bool, ExifImport, false)
 property_copy(useModDateIfNoExif, setUseModDateIfNoExif, bool, ExifImport, true)
 property_copy(updateOrientation, setUpdateOrientation, bool, ExifImport, false)
 property_copy(updateDescription, setUpdateDescription, bool, ExifImport, false)
     // clang-format on
 
     ///////////////////////
     //// Miscellaneous ////
     ///////////////////////
 
     // clang-format off
 property_copy(delayLoadingPlugins, setDelayLoadingPlugins, bool, Plug - ins, true)
 
 property_ref_(HTMLBaseDir, setHTMLBaseDir, QString, groupForDatabase("HTML Settings"), QString::fromLocal8Bit(qgetenv("HOME")) + STR("/public_html"))
 property_ref_(HTMLBaseURL, setHTMLBaseURL, QString, groupForDatabase("HTML Settings"), STR("file://") + HTMLBaseDir())
 property_ref_(HTMLDestURL, setHTMLDestURL, QString, groupForDatabase("HTML Settings"), STR("file://") + HTMLBaseDir())
 property_ref_(HTMLCopyright, setHTMLCopyright, QString, groupForDatabase("HTML Settings"), STR(""))
 property_ref_(HTMLDate, setHTMLDate, int, groupForDatabase("HTML Settings"), true)
 property_ref_(HTMLTheme, setHTMLTheme, int, groupForDatabase("HTML Settings"), -1)
 property_ref_(HTMLKimFile, setHTMLKimFile, int, groupForDatabase("HTML Settings"), true)
 property_ref_(HTMLInlineMovies, setHTMLInlineMovies, int, groupForDatabase("HTML Settings"), true)
 property_ref_(HTML5Video, setHTML5Video, int, groupForDatabase("HTML Settings"), true)
 property_ref_(HTML5VideoGenerate, setHTML5VideoGenerate, int, groupForDatabase("HTML Settings"), true)
 property_ref_(HTMLThumbSize, setHTMLThumbSize, int, groupForDatabase("HTML Settings"), 128)
 property_ref_(HTMLNumOfCols, setHTMLNumOfCols, int, groupForDatabase("HTML Settings"), 5)
 property_ref_(HTMLSizes, setHTMLSizes, QString, groupForDatabase("HTML Settings"), STR(""))
 property_ref_(HTMLIncludeSelections, setHTMLIncludeSelections, QString, groupForDatabase("HTML Settings"), STR(""))
 property_ref_(password, setPassword, QString, groupForDatabase("Privacy Settings"), STR(""))
     // clang-format on
 
     QDate SettingsData::fromDate() const
 {
     QString date = value("Miscellaneous", "fromDate", STR(""));
     return date.isEmpty() ? QDate(QDate::currentDate().year(), 1, 1) : QDate::fromString(date, Qt::ISODate);
 }
 
 void SettingsData::setFromDate(const QDate &date)
 {
     if (date.isValid())
         setValue("Miscellaneous", "fromDate", date.toString(Qt::ISODate));
 }
 
 QDate SettingsData::toDate() const
 {
     QString date = value("Miscellaneous", "toDate", STR(""));
     return date.isEmpty() ? QDate(QDate::currentDate().year() + 1, 1, 1) : QDate::fromString(date, Qt::ISODate);
 }
 
 void SettingsData::setToDate(const QDate &date)
 {
     if (date.isValid())
         setValue("Miscellaneous", "toDate", date.toString(Qt::ISODate));
 }
 
 QString SettingsData::imageDirectory() const
 {
     return m_imageDirectory;
 }
 
 QString SettingsData::groupForDatabase(const char *setting) const
 {
     return STR("%1 - %2").arg(STR(setting)).arg(imageDirectory());
 }
 
 DB::ImageSearchInfo SettingsData::currentLock() const
 {
     return DB::ImageSearchInfo::loadLock();
 }
 
 void SettingsData::setCurrentLock(const DB::ImageSearchInfo &info, bool exclude)
 {
     info.saveLock();
     setValue(groupForDatabase("Privacy Settings"), "exclude", exclude);
 }
 
 bool SettingsData::lockExcludes() const
 {
     return value(groupForDatabase("Privacy Settings"), "exclude", false);
 }
 
 getValueFunc_(bool, locked, groupForDatabase("Privacy Settings"), "locked", false)
 
     void SettingsData::setLocked(bool lock, bool force)
 {
     if (lock == locked() && !force)
         return;
 
     setValue(groupForDatabase("Privacy Settings"), "locked", lock);
     emit locked(lock, lockExcludes());
 }
 
 void SettingsData::setWindowGeometry(WindowType win, const QRect &geometry)
 {
     setValue("Window Geometry", win, geometry);
 }
 
 QRect SettingsData::windowGeometry(WindowType win) const
 {
     return value("Window Geometry", win, QRect(0, 0, 800, 600));
 }
 
 bool Settings::SettingsData::hasUntaggedCategoryFeatureConfigured() const
 {
     return DB::ImageDB::instance()->categoryCollection()->categoryNames().contains(untaggedCategory())
         && DB::ImageDB::instance()->categoryCollection()->categoryForName(untaggedCategory())->items().contains(untaggedTag());
 }
 
 double Settings::SettingsData::getThumbnailAspectRatio() const
 {
     double ratio = 1.0;
     switch (Settings::SettingsData::instance()->thumbnailAspectRatio()) {
     case Settings::Aspect_16_9:
         ratio = 9.0 / 16;
         break;
     case Settings::Aspect_4_3:
         ratio = 3.0 / 4;
         break;
     case Settings::Aspect_3_2:
         ratio = 2.0 / 3;
         break;
     case Settings::Aspect_9_16:
         ratio = 16 / 9.0;
         break;
     case Settings::Aspect_3_4:
         ratio = 4 / 3.0;
         break;
     case Settings::Aspect_2_3:
         ratio = 3 / 2.0;
         break;
     case Settings::Aspect_1_1:
         ratio = 1.0;
         break;
     }
     return ratio;
 }
 
 QStringList Settings::SettingsData::EXIFCommentsToStrip()
 {
     return m_EXIFCommentsToStrip;
 }
 
 void Settings::SettingsData::setEXIFCommentsToStrip(QStringList EXIFCommentsToStrip)
 {
     m_EXIFCommentsToStrip = EXIFCommentsToStrip;
 }
 
 bool Settings::SettingsData::getOverlapLoadMD5() const
 {
     switch (Settings::SettingsData::instance()->loadOptimizationPreset()) {
     case Settings::LoadOptimizationSlowNVME:
     case Settings::LoadOptimizationFastNVME:
         return true;
         break;
     case Settings::LoadOptimizationManual:
         return Settings::SettingsData::instance()->overlapLoadMD5();
         break;
     case Settings::LoadOptimizationHardDisk:
     case Settings::LoadOptimizationNetwork:
     case Settings::LoadOptimizationSataSSD:
     default:
         return false;
         break;
     }
 }
 
 int Settings::SettingsData::getPreloadThreadCount() const
 {
     switch (Settings::SettingsData::instance()->loadOptimizationPreset()) {
     case Settings::LoadOptimizationManual:
         return Settings::SettingsData::instance()->preloadThreadCount();
         break;
     case Settings::LoadOptimizationSlowNVME:
     case Settings::LoadOptimizationFastNVME:
     case Settings::LoadOptimizationSataSSD:
         return qMax(1, qMin(16, QThread::idealThreadCount()));
         break;
     case Settings::LoadOptimizationHardDisk:
     case Settings::LoadOptimizationNetwork:
     default:
         return 1;
         break;
     }
 }
 
 int Settings::SettingsData::getThumbnailPreloadThreadCount() const
 {
     switch (Settings::SettingsData::instance()->loadOptimizationPreset()) {
     case Settings::LoadOptimizationManual:
         return Settings::SettingsData::instance()->thumbnailPreloadThreadCount();
         break;
     case Settings::LoadOptimizationSlowNVME:
     case Settings::LoadOptimizationFastNVME:
     case Settings::LoadOptimizationSataSSD:
         return qMax(1, qMin(16, QThread::idealThreadCount() / 2));
         break;
     case Settings::LoadOptimizationHardDisk:
     case Settings::LoadOptimizationNetwork:
     default:
         return 1;
         break;
     }
 }
 
 int Settings::SettingsData::getThumbnailBuilderThreadCount() const
 {
     switch (Settings::SettingsData::instance()->loadOptimizationPreset()) {
     case Settings::LoadOptimizationManual:
         return Settings::SettingsData::instance()->thumbnailBuilderThreadCount();
         break;
     case Settings::LoadOptimizationSlowNVME:
     case Settings::LoadOptimizationFastNVME:
     case Settings::LoadOptimizationSataSSD:
     case Settings::LoadOptimizationHardDisk:
     case Settings::LoadOptimizationNetwork:
     default:
         return qMax(1, qMin(16, QThread::idealThreadCount() - 1));
         break;
     }
 }
 
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/Settings/SettingsData.h b/Settings/SettingsData.h
index da44c085..d4eee10d 100644
--- a/Settings/SettingsData.h
+++ b/Settings/SettingsData.h
@@ -1,289 +1,290 @@
-/* Copyright (C) 2003-2019 The KPhotoAlbum Development Team
+/* Copyright (C) 2003-2020 The KPhotoAlbum Development Team
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef SETTINGS_SETTINGSDATA_H
 #define SETTINGS_SETTINGSDATA_H
 
 #include <AnnotationDialog/enums.h>
 #include <DB/Category.h>
 #include <DB/ImageSearchInfo.h>
 #include <Exif/Info.h>
 #include <Utilities/StringSet.h>
 
 #define property(GET_TYPE, GET_FUNC, SET_FUNC, SET_TYPE) \
     GET_TYPE GET_FUNC() const;                           \
     void SET_FUNC(const SET_TYPE)
 
 #define property_copy(GET_FUNC, SET_FUNC, TYPE) property(TYPE, GET_FUNC, SET_FUNC, TYPE)
 #define property_ref(GET_FUNC, SET_FUNC, TYPE) property(TYPE, GET_FUNC, SET_FUNC, TYPE &)
 
 namespace DB
 {
 class CategoryCollection;
 }
 
 namespace Settings
 {
 using Utilities::StringSet;
 
 enum Position { Bottom,
                 Top,
                 Left,
                 Right,
                 TopLeft,
                 TopRight,
                 BottomLeft,
                 BottomRight };
 enum ViewSortType { SortLastUse,
                     SortAlphaTree,
                     SortAlphaFlat };
 enum TimeStampTrust { Always,
                       Ask,
                       Never };
 enum StandardViewSize { FullSize,
                         NaturalSize,
                         NaturalSizeIfFits };
 enum ThumbnailAspectRatio { Aspect_1_1,
                             Aspect_4_3,
                             Aspect_3_2,
                             Aspect_16_9,
                             Aspect_3_4,
                             Aspect_2_3,
                             Aspect_9_16 };
 enum LoadOptimizationPreset { LoadOptimizationHardDisk,
                               LoadOptimizationNetwork,
                               LoadOptimizationSataSSD,
                               LoadOptimizationSlowNVME,
                               LoadOptimizationFastNVME,
                               LoadOptimizationManual };
 
 typedef const char *WindowType;
 extern const WindowType MainWindow, AnnotationDialog;
 
 class SettingsData : public QObject
 {
     Q_OBJECT
 
 public:
     static SettingsData *instance();
     static bool ready();
     static void setup(const QString &imageDirectory);
 
     /////////////////
     //// General ////
     /////////////////
 
     property_ref(histogramSize, setHistogramSize, QSize);
     property_copy(useEXIFRotate, setUseEXIFRotate, bool);
     property_copy(useEXIFComments, setUseEXIFComments, bool);
     property_copy(stripEXIFComments, setStripEXIFComments, bool);
     property_copy(commentsToStrip, setCommentsToStrip, QString);
     property_copy(searchForImagesOnStart, setSearchForImagesOnStart, bool);
     property_copy(ignoreFileExtension, setIgnoreFileExtension, bool);
     property_copy(skipSymlinks, setSkipSymlinks, bool);
     property_copy(skipRawIfOtherMatches, setSkipRawIfOtherMatches, bool);
     property_copy(useRawThumbnail, setUseRawThumbnail, bool);
     property_copy(useRawThumbnailSize, setUseRawThumbnailSize, QSize);
     property_copy(useCompressedIndexXML, setUseCompressedIndexXML, bool);
     property_copy(compressBackup, setCompressBackup, bool);
     property_copy(showSplashScreen, setShowSplashScreen, bool);
     property_copy(showHistogram, setShowHistogram, bool);
     property_copy(histogramUseLinearScale, setHistogramUseLinearScale, bool);
     property_copy(autoSave, setAutoSave, int);
     property_copy(backupCount, setBackupCount, int);
     property_copy(viewSortType, setViewSortType, ViewSortType);
     property_copy(matchType, setMatchType, AnnotationDialog::MatchType);
     property_copy(tTimeStamps, setTTimeStamps, TimeStampTrust);
     property_copy(excludeDirectories, setExcludeDirectories, QString);
 #ifdef KPA_ENABLE_REMOTECONTROL
     property_copy(recentAndroidAddress, setRecentAndroidAddress, QString);
     property_copy(listenForAndroidDevicesOnStartup, setListenForAndroidDevicesOnStartup, bool);
 #endif
 
     ////////////////////////////////
     //// File Version Detection ////
     ////////////////////////////////
 
     property_copy(detectModifiedFiles, setDetectModifiedFiles, bool);
     property_copy(modifiedFileComponent, setModifiedFileComponent, QString);
     property_copy(originalFileComponent, setOriginalFileComponent, QString);
     property_copy(moveOriginalContents, setMoveOriginalContents, bool);
     property_copy(autoStackNewFiles, setAutoStackNewFiles, bool);
     property_copy(copyFileComponent, setCopyFileComponent, QString);
     property_copy(copyFileReplacementComponent, setCopyFileReplacementComponent, QString);
     property_copy(loadOptimizationPreset, setLoadOptimizationPreset, int);
     property_copy(overlapLoadMD5, setOverlapLoadMD5, bool);
     property_copy(preloadThreadCount, setPreloadThreadCount, int);
     property_copy(thumbnailPreloadThreadCount, setThumbnailPreloadThreadCount, int);
     property_copy(thumbnailBuilderThreadCount, setThumbnailBuilderThreadCount, int);
 
     bool trustTimeStamps();
 
     ////////////////////
     //// Thumbnails ////
     ////////////////////
 
     property_copy(displayLabels, setDisplayLabels, bool);
     property_copy(displayCategories, setDisplayCategories, bool);
     property_copy(autoShowThumbnailView, setAutoShowThumbnailView, int);
     property_copy(showNewestThumbnailFirst, setShowNewestFirst, bool);
     property_copy(thumbnailDisplayGrid, setThumbnailDisplayGrid, bool);
     property_copy(previewSize, setPreviewSize, int);
     property_ref(backgroundColor, setBackgroundColor, QString);
+    property_copy(colorScheme, setColorScheme, QString);
     property_copy(incrementalThumbnails, setIncrementalThumbnails, bool);
 
     // Border space around thumbnails.
     property_copy(thumbnailSpace, setThumbnailSpace, int);
     property_copy(thumbnailSize, setThumbnailSize, int);
     property_copy(minimumThumbnailSize, setMinimumThumbnailSize, int);
     property_copy(maximumThumbnailSize, setMaximumThumbnailSize, int);
     property_copy(actualThumbnailSize, setActualThumbnailSize, int);
     property_copy(thumbnailAspectRatio, setThumbnailAspectRatio, ThumbnailAspectRatio);
 
     ////////////////
     //// Viewer ////
     ////////////////
 
     property_ref(viewerSize, setViewerSize, QSize);
     property_ref(slideShowSize, setSlideShowSize, QSize);
     property_copy(launchViewerFullScreen, setLaunchViewerFullScreen, bool);
     property_copy(launchSlideShowFullScreen, setLaunchSlideShowFullScreen, bool);
     property_copy(showInfoBox, setShowInfoBox, bool);
     property_copy(showLabel, setShowLabel, bool);
     property_copy(showDescription, setShowDescription, bool);
     property_copy(showDate, setShowDate, bool);
     property_copy(showImageSize, setShowImageSize, bool);
     property_copy(showRating, setShowRating, bool);
     property_copy(showTime, setShowTime, bool);
     property_copy(showFilename, setShowFilename, bool);
     property_copy(showEXIF, setShowEXIF, bool);
     property_copy(smoothScale, setSmoothScale, bool);
     property_copy(slideShowInterval, setSlideShowInterval, int);
     property_copy(viewerCacheSize, setViewerCacheSize, int);
     property_copy(infoBoxWidth, setInfoBoxWidth, int);
     property_copy(infoBoxHeight, setInfoBoxHeight, int);
     property_copy(infoBoxPosition, setInfoBoxPosition, Position);
     property_copy(viewerStandardSize, setViewerStandardSize, StandardViewSize);
 
     ////////////////////
     //// Categories ////
     ////////////////////
 
     property_ref(albumCategory, setAlbumCategory, QString);
     property_ref(untaggedCategory, setUntaggedCategory, QString);
     property_ref(untaggedTag, setUntaggedTag, QString);
     bool hasUntaggedCategoryFeatureConfigured() const;
     property_copy(untaggedImagesTagVisible, setUntaggedImagesTagVisible, bool);
 
     //////////////
     //// Exif ////
     //////////////
 
     property_ref(exifForViewer, setExifForViewer, StringSet);
     property_ref(exifForDialog, setExifForDialog, StringSet);
     property_ref(iptcCharset, setIptcCharset, QString);
 
     /////////////////////
     //// Exif Import ////
     /////////////////////
 
     property_copy(updateExifData, setUpdateExifData, bool);
     property_copy(updateImageDate, setUpdateImageDate, bool);
     property_copy(useModDateIfNoExif, setUseModDateIfNoExif, bool);
     property_copy(updateOrientation, setUpdateOrientation, bool);
     property_copy(updateDescription, setUpdateDescription, bool);
 
     ///////////////////////
     //// Miscellaneous ////
     ///////////////////////
 
     property_copy(delayLoadingPlugins, setDelayLoadingPlugins, bool);
 
     property_ref(password, setPassword, QString);
 
     property_ref(HTMLBaseDir, setHTMLBaseDir, QString);
     property_ref(HTMLBaseURL, setHTMLBaseURL, QString);
     property_ref(HTMLDestURL, setHTMLDestURL, QString);
     property_ref(HTMLCopyright, setHTMLCopyright, QString);
     property_ref(HTMLDate, setHTMLDate, int);
     property_ref(HTMLTheme, setHTMLTheme, int);
     property_ref(HTMLKimFile, setHTMLKimFile, int);
     property_ref(HTMLInlineMovies, setHTMLInlineMovies, int);
     property_ref(HTML5Video, setHTML5Video, int);
     property_ref(HTML5VideoGenerate, setHTML5VideoGenerate, int);
     property_ref(HTMLThumbSize, setHTMLThumbSize, int);
     property_ref(HTMLNumOfCols, setHTMLNumOfCols, int);
     property_ref(HTMLSizes, setHTMLSizes, QString);
     property_ref(HTMLIncludeSelections, setHTMLIncludeSelections, QString);
 
     property_ref(fromDate, setFromDate, QDate);
     property_ref(toDate, setToDate, QDate);
 
     QString imageDirectory() const;
 
     QString groupForDatabase(const char *setting) const;
 
     DB::ImageSearchInfo currentLock() const;
     void setCurrentLock(const DB::ImageSearchInfo &, bool exclude);
     bool lockExcludes() const;
 
     bool locked() const;
     void setLocked(bool locked, bool force);
 
     void setWindowGeometry(WindowType, const QRect &geometry);
     QRect windowGeometry(WindowType) const;
 
     double getThumbnailAspectRatio() const;
 
     QStringList EXIFCommentsToStrip();
     void setEXIFCommentsToStrip(QStringList EXIFCommentsToStrip);
 
     bool getOverlapLoadMD5() const;
     int getPreloadThreadCount() const;
     int getThumbnailPreloadThreadCount() const;
     int getThumbnailBuilderThreadCount() const;
 
 signals:
     void locked(bool lock, bool exclude);
     void viewSortTypeChanged(Settings::ViewSortType);
     void matchTypeChanged(AnnotationDialog::MatchType);
     void histogramSizeChanged(const QSize &);
     void thumbnailSizeChanged(int);
     void actualThumbnailSizeChanged(int);
     void histogramScaleChanged();
 
 private:
     SettingsData(const QString &imageDirectory);
 
     bool m_trustTimeStamps;
     bool m_hasAskedAboutTimeStamps;
     QString m_imageDirectory;
     static SettingsData *s_instance;
 
     friend class DB::CategoryCollection;
 
     QStringList m_EXIFCommentsToStrip;
 };
 } // end of namespace
 
 #undef property
 #undef property_copy
 #undef property_ref
 
 #endif /* SETTINGS_SETTINGSDATA_H */
 // vi:expandtab:tabstop=4 shiftwidth=4:
diff --git a/kphotoalbumui.rc b/kphotoalbumui.rc
index 4fbb4006..fcc85a0b 100644
--- a/kphotoalbumui.rc
+++ b/kphotoalbumui.rc
@@ -1,107 +1,108 @@
 <!DOCTYPE kpartgui>
-<kpartgui name="kphotoalbum" version="46">
+<kpartgui name="kphotoalbum" version="47">
   <MenuBar>
     <Menu name="file">
       <Action name="exportHTML"/>
       <Action name="import"/>
       <Action name="export"/>
     </Menu>
     <Menu name="edit" >
       <Action name="edit_copy" />
       <Action name="edit_paste" />
       <Action name="edit_select_all" />
       <Action name="edit_deselect" />
       <Separator/>
       <Action name="deleteSelected" />
       <Action name="removeTokens" />
       <Action name="showListOfFiles" />
       <Separator/>
       <Action name="rotateLeft" />
       <Action name="rotateRight" />
       <Separator/>
       <Action name="oneProp"/>
       <Action name="allProp"/>
       <Action name="createImageStack"/>
       <Action name="unStackImages"/>
       <Action name="setStackHead"/>
     </Menu>
     <Menu name="view" >
       <text>&amp;View</text>
       <Action name="viewImages" />
       <Action name="viewImagesNewWindow" />
       <Action name="runSlideShow"/>
       <Action name="runRandomizedSlideShow"/>
       <Action name="collapseAllStacks"/>
       <Action name="expandAllStacks"/>
       <Separator/>
       <Action name="jumpToContext"/>
       <Action name="limitToMarked" />
       <Separator/>
       <Action name="sortImages" />
       <Action name="orderIncr"/>
       <Action name="orderDecr"/>
       <Menu name="privacy">
         <text>Privacy</text>
         <Action name="lockToDefaultScope"/>
         <Action name="unlockFromDefaultScope"/>
         <Action name="changeScopePasswd" />
         <Separator/>
         <Action name="setDefaultScopeNegative" />
         <Action name="setDefaultScopePositive" />
       </Menu>
     </Menu>
     <Menu name="maintenance">
       <text>&amp;Maintenance</text>
       <Action name="findUnavailableImages"/>
       <Action name="findImagesWithInvalidDate"/>
       <Action name="findImagesWithChangedMD5Sum"/>
       <Action name="mergeDuplicates"/>
       <Separator/>
       <Action name="rebuildMD5s"/>
       <Action name="rescan"/>
       <Action name="recreateExifDB" />
       <Action name="reReadExifInfo" />
       <Action name="sortAllImages" />
       <Action name="autoStack" />
       <Separator/>
       <Action name="removeAllThumbs"/>
       <Action name="buildThumbs"/>
       <Action name="optimizeThumbs"/>
       <Separator/>
       <Action name="markUntagged"/>
       <Separator/>
       <Action name="statistics"/>
     </Menu>
     <Menu name="plugins">
       <text>Plugins</text>
       <Menu name="kipiplugins">
         <text>Legacy Plugins (KIPI)</text>
         <ActionList name="kipi_actions"/>
       </Menu>
    </Menu>
    <Menu name="settings">
      <Action name="readdAllMessages"/>
      <Action name="showToolTipOnImages"/>
      <Action name="configureView"/>
      <Action name="toggleFilterToolbar"/>
      <Action name="toggleSearchBar"/>
+     <Action name="colorScheme"/>
    </Menu>
    <Menu name="help">
      <Action name="runDemo"/>
      <Action name="features"/>
      <Action name="showVideo"/>
    </Menu>
   </MenuBar>
 
   <ToolBar noMerge="1"  name="mainToolBar">
     <text>Main Toolbar</text>
     <Action name="file_save"/>
     <Action name="go_home"/>
     <Action name="go_back"/>
     <Action name="go_forward"/>
     <Action name="view_redisplay"/>
     <Action name="runSlideShow"/>
   </ToolBar>
 
 
 </kpartgui>