diff --git a/libs/libqml/Settings.cpp b/libs/libqml/Settings.cpp
index b08c5bd98e..ebf61a2bfb 100644
--- a/libs/libqml/Settings.cpp
+++ b/libs/libqml/Settings.cpp
@@ -1,144 +1,144 @@
 /* This file is part of the KDE project
  * Copyright (C) 2012 Arjen Hiemstra <ahiemstra@heimr.nl>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "Settings.h"
 #include <QApplication>
 
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 #include <kis_paintop_preset.h>
 #include "KisResourceServerProvider.h"
 
 #include "Theme.h"
 #include "PropertyContainer.h"
 #include <kis_config.h>
 
 class Settings::Private
 {
 public:
     Private() : temporaryFile(false), focusItem(0), theme(0){ }
 
     QString currentFile;
     bool temporaryFile;
     QQuickItem *focusItem;
     Theme* theme {0};
 };
 
 Settings::Settings( QObject* parent )
     : QObject( parent )
     , d( new Private )
 {
 }
 
 Settings::~Settings()
 {
     delete d;
 }
 
 void Settings::setTheme(Theme *theme)
 {
     d->theme = theme;
     d->theme->setParent(this);
     connect(d->theme, SIGNAL(fontCacheRebuilt()), SIGNAL(themeChanged()));
 
 }
 
 
 QString Settings::currentFile() const
 {
     return d->currentFile;
 }
 
 void Settings::setCurrentFile(const QString& fileName)
 {
     qApp->processEvents();
     if (fileName != d->currentFile) {
         d->currentFile = fileName;
         emit currentFileChanged();
     }
 }
 
 bool Settings::isTemporaryFile() const
 {
     return d->temporaryFile;
 }
 
 void Settings::setTemporaryFile(bool temp)
 {
     if (temp != d->temporaryFile) {
         d->temporaryFile = temp;
         emit temporaryFileChanged();
     }
 }
 
 QQuickItem* Settings::focusItem()
 {
     return d->focusItem;
 }
 
 void Settings::setFocusItem(QQuickItem* item)
 {
     if (item != d->focusItem) {
         d->focusItem = item;
         emit focusItemChanged();
     }
 }
 
 QObject* Settings::theme() const
 {
     return d->theme;
 }
 
 QString Settings::themeID() const
 {
     if(d->theme)
         return d->theme->id();
 
     return QString();
 }
 
 void Settings::setThemeID(const QString& /*id*/)
 {
 //    if(!d->theme || id != d->theme->id()) {
 //        if(d->theme) {
 //            delete d->theme;
 //            d->theme = 0;
 //        }
 
 //        d->theme = Theme::load(id, this);
 //        KSharedConfig::openConfig()->group("General").writeEntry<QString>("theme", id);
 
 //        emit themeChanged();
 //    }
 }
 
 QObject* Settings::customImageSettings() const
 {
     QObject* settings = new PropertyContainer("customImageSettings", qApp);
     KisConfig cfg(false);
     settings->setProperty("Width", cfg.defImageWidth());
     settings->setProperty("Height", cfg.defImageHeight());
     settings->setProperty("Resolution", qRound(cfg.defImageResolution() * 72)); // otherwise we end up with silly floating point numbers
     settings->setProperty("ColorModel", cfg.defColorModel());
-    settings->setProperty("ColorDepth", cfg.defaultColorDepth());
+    settings->setProperty("ColorDepth", cfg.defColorDepth());
     settings->setProperty("ColorProfile", cfg.defColorProfile());
     return settings;
 }
 
diff --git a/libs/ui/KisDocument.cpp b/libs/ui/KisDocument.cpp
index 198f337b36..f2ed5b48e4 100644
--- a/libs/ui/KisDocument.cpp
+++ b/libs/ui/KisDocument.cpp
@@ -1,2346 +1,2348 @@
 /* This file is part of the Krita project
  *
  * Copyright (C) 2014 Boudewijn Rempt <boud@valdyas.org>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library 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
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "KisMainWindow.h" // XXX: remove
 #include <QMessageBox> // XXX: remove
 
 #include <KisMimeDatabase.h>
 
 #include <KoCanvasBase.h>
 #include <KoColor.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoColorSpace.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoDocumentInfoDlg.h>
 #include <KoDocumentInfo.h>
 #include <KoDpi.h>
 #include <KoUnit.h>
 #include <KoID.h>
 #include <KoProgressProxy.h>
 #include <KoProgressUpdater.h>
 #include <KoSelection.h>
 #include <KoShape.h>
 #include <KoShapeController.h>
 #include <KoStore.h>
 #include <KoUpdater.h>
 #include <KoXmlWriter.h>
 #include <KoXmlReader.h>
 #include <KoStoreDevice.h>
 #include <KoDialog.h>
 #include <KisImportExportErrorCode.h>
 #include <KoDocumentResourceManager.h>
 #include <KoMD5Generator.h>
 #include <KisResourceStorage.h>
 #include <KisResourceLocator.h>
 #include <KisResourceTypes.h>
 #include <KisGlobalResourcesInterface.h>
 
 #include <KisUsageLogger.h>
 #include <klocalizedstring.h>
 #include "kis_scratch_pad.h"
 #include <kis_debug.h>
 #include <kis_generator_layer.h>
 #include <kis_generator_registry.h>
 #include <kdesktopfile.h>
 #include <kconfiggroup.h>
 #include <kbackup.h>
 #include <KisView.h>
 
 #include <QTextBrowser>
 #include <QApplication>
 #include <QBuffer>
 #include <QStandardPaths>
 #include <QDir>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QFileInfo>
 #include <QImage>
 #include <QList>
 #include <QPainter>
 #include <QRect>
 #include <QScopedPointer>
 #include <QSize>
 #include <QStringList>
 #include <QtGlobal>
 #include <QTimer>
 #include <QWidget>
 #include <QFuture>
 #include <QFutureWatcher>
 #include <QUuid>
 
 // Krita Image
 #include <kis_image_animation_interface.h>
 #include <kis_config.h>
 #include <flake/kis_shape_layer.h>
 #include <kis_group_layer.h>
 #include <kis_image.h>
 #include <kis_layer.h>
 #include <kis_name_server.h>
 #include <kis_paint_layer.h>
 #include <kis_painter.h>
 #include <kis_selection.h>
 #include <kis_fill_painter.h>
 #include <kis_document_undo_store.h>
 #include <kis_idle_watcher.h>
 #include <kis_signal_auto_connection.h>
 #include <kis_canvas_widget_base.h>
 #include "kis_layer_utils.h"
 #include "kis_selection_mask.h"
 
 // Local
 #include "KisViewManager.h"
 #include "kis_clipboard.h"
 #include "widgets/kis_custom_image_widget.h"
 #include "canvas/kis_canvas2.h"
 #include "flake/kis_shape_controller.h"
 #include "kis_statusbar.h"
 #include "widgets/kis_progress_widget.h"
 #include "kis_canvas_resource_provider.h"
 #include "KisResourceServerProvider.h"
 #include "kis_node_manager.h"
 #include "KisPart.h"
 #include "KisApplication.h"
 #include "KisDocument.h"
 #include "KisImportExportManager.h"
 #include "KisView.h"
 #include "kis_grid_config.h"
 #include "kis_guides_config.h"
 #include "kis_image_barrier_lock_adapter.h"
 #include "KisReferenceImagesLayer.h"
 #include "dialogs/KisRecoverNamedAutosaveDialog.h"
 
 #include <mutex>
 #include "kis_config_notifier.h"
 #include "kis_async_action_feedback.h"
 #include "KisCloneDocumentStroke.h"
 
 #include <KisMirrorAxisConfig.h>
 #include <KisDecorationsWrapperLayer.h>
 #include "kis_simple_stroke_strategy.h"
 
 // Define the protocol used here for embedded documents' URL
 // This used to "store" but QUrl didn't like it,
 // so let's simply make it "tar" !
 #define STORE_PROTOCOL "tar"
 // The internal path is a hack to make QUrl happy and for document children
 #define INTERNAL_PROTOCOL "intern"
 #define INTERNAL_PREFIX "intern:/"
 // Warning, keep it sync in koStore.cc
 
 #include <unistd.h>
 
 using namespace std;
 
 namespace {
 constexpr int errorMessageTimeout = 5000;
 constexpr int successMessageTimeout = 1000;
 }
 
 
 /**********************************************************
  *
  * KisDocument
  *
  **********************************************************/
 
 //static
 QString KisDocument::newObjectName()
 {
     static int s_docIFNumber = 0;
     QString name; name.setNum(s_docIFNumber++); name.prepend("document_");
     return name;
 }
 
 
 class UndoStack : public KUndo2Stack
 {
 public:
     UndoStack(KisDocument *doc)
         : KUndo2Stack(doc),
           m_doc(doc)
     {
     }
 
     void setIndex(int idx) override {
         KisImageWSP image = this->image();
         image->requestStrokeCancellation();
         if(image->tryBarrierLock()) {
             KUndo2Stack::setIndex(idx);
             image->unlock();
         }
     }
 
     void notifySetIndexChangedOneCommand() override {
         KisImageWSP image = this->image();
         image->unlock();
 
         /**
          * Some very weird commands may emit blocking signals to
          * the GUI (e.g. KisGuiContextCommand). Here is the best thing
          * we can do to avoid the deadlock
          */
         while(!image->tryBarrierLock()) {
             QApplication::processEvents();
         }
     }
 
     void undo() override {
         KisImageWSP image = this->image();
         image->requestUndoDuringStroke();
 
         if (image->tryUndoUnfinishedLod0Stroke() == UNDO_OK) {
             return;
         }
 
         if(image->tryBarrierLock()) {
             KUndo2Stack::undo();
             image->unlock();
         }
     }
 
     void redo() override {
         KisImageWSP image = this->image();
         if(image->tryBarrierLock()) {
             KUndo2Stack::redo();
             image->unlock();
         }
     }
 
 private:
     KisImageWSP image() {
         KisImageWSP currentImage = m_doc->image();
         Q_ASSERT(currentImage);
         return currentImage;
     }
 
 private:
     KisDocument *m_doc;
 };
 
 class Q_DECL_HIDDEN KisDocument::Private
 {
 public:
     Private(KisDocument *_q)
         : q(_q)
         , docInfo(new KoDocumentInfo(_q)) // deleted by QObject
         , importExportManager(new KisImportExportManager(_q)) // deleted manually
         , autoSaveTimer(new QTimer(_q))
         , undoStack(new UndoStack(_q)) // deleted by QObject
         , m_bAutoDetectedMime(false)
         , modified(false)
         , readwrite(true)
         , firstMod(QDateTime::currentDateTime())
         , lastMod(firstMod)
         , nserver(new KisNameServer(1))
         , imageIdleWatcher(2000 /*ms*/)
         , globalAssistantsColor(KisConfig(true).defaultAssistantsColor())
         , savingLock(&savingMutex)
         , batchMode(false)
     {
         if (QLocale().measurementSystem() == QLocale::ImperialSystem) {
             unit = KoUnit::Inch;
         } else {
             unit = KoUnit::Centimeter;
         }
         connect(&imageIdleWatcher, SIGNAL(startedIdleMode()), q, SLOT(slotPerformIdleRoutines()));
     }
 
     Private(const Private &rhs, KisDocument *_q)
         : q(_q)
         , docInfo(new KoDocumentInfo(*rhs.docInfo, _q))
         , importExportManager(new KisImportExportManager(_q))
         , autoSaveTimer(new QTimer(_q))
         , undoStack(new UndoStack(_q))
         , nserver(new KisNameServer(*rhs.nserver))
         , preActivatedNode(0) // the node is from another hierarchy!
         , imageIdleWatcher(2000 /*ms*/)
         , savingLock(&savingMutex)
     {
         copyFromImpl(rhs, _q, CONSTRUCT);
         connect(&imageIdleWatcher, SIGNAL(startedIdleMode()), q, SLOT(slotPerformIdleRoutines()));
     }
 
     ~Private() {
         // Don't delete m_d->shapeController because it's in a QObject hierarchy.
         delete nserver;
     }
 
     KisDocument *q = 0;
     KoDocumentInfo *docInfo = 0;
 
     KoUnit unit;
 
     KisImportExportManager *importExportManager = 0; // The filter-manager to use when loading/saving [for the options]
 
     QByteArray mimeType; // The actual mimetype of the document
     QByteArray outputMimeType; // The mimetype to use when saving
 
     QTimer *autoSaveTimer;
     QString lastErrorMessage; // see openFile()
     QString lastWarningMessage;
     int autoSaveDelay = 300; // in seconds, 0 to disable.
     bool modifiedAfterAutosave = false;
     bool isAutosaving = false;
     bool disregardAutosaveFailure = false;
     int autoSaveFailureCount = 0;
 
     KUndo2Stack *undoStack = 0;
 
     KisGuidesConfig guidesConfig;
     KisMirrorAxisConfig mirrorAxisConfig;
 
     bool m_bAutoDetectedMime = false; // whether the mimetype in the arguments was detected by the part itself
     QUrl m_url; // local url - the one displayed to the user.
     QString m_file; // Local file - the only one the part implementation should deal with.
 
     QMutex savingMutex;
 
     bool modified = false;
     bool readwrite = false;
 
     QDateTime firstMod;
     QDateTime lastMod;
 
     KisNameServer *nserver;
 
     KisImageSP image;
     KisImageSP savingImage;
 
     KisNodeWSP preActivatedNode;
     KisShapeController* shapeController = 0;
     KoShapeController* koShapeController = 0;
     KisIdleWatcher imageIdleWatcher;
     QScopedPointer<KisSignalAutoConnection> imageIdleConnection;
 
     QList<KisPaintingAssistantSP> assistants;
 
     QColor globalAssistantsColor;
 
     KisSharedPtr<KisReferenceImagesLayer> referenceImagesLayer;
     KisGridConfig gridConfig;
 
     StdLockableWrapper<QMutex> savingLock;
 
     bool modifiedWhileSaving = false;
     QScopedPointer<KisDocument> backgroundSaveDocument;
     QPointer<KoUpdater> savingUpdater;
     QFuture<KisImportExportErrorCode> childSavingFuture;
     KritaUtils::ExportFileJob backgroundSaveJob;
 
     bool isRecovered = false;
 
     bool batchMode { false };
 
     QString documentStorageID {QUuid::createUuid().toString()};
     KisResourceStorageSP documentResourceStorage;
 
     void syncDecorationsWrapperLayerState();
 
     void setImageAndInitIdleWatcher(KisImageSP _image) {
         image = _image;
 
         imageIdleWatcher.setTrackedImage(image);
     }
 
     void copyFrom(const Private &rhs, KisDocument *q);
     void copyFromImpl(const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy);
 
     /// clones the palette list oldList
     /// the ownership of the returned KoColorSet * belongs to the caller
     class StrippedSafeSavingLocker;
 };
 
 
 void KisDocument::Private::syncDecorationsWrapperLayerState()
 {
     if (!this->image) return;
 
     KisImageSP image = this->image;
     KisDecorationsWrapperLayerSP decorationsLayer =
         KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(image->root());
 
     const bool needsDecorationsWrapper =
             gridConfig.showGrid() || (guidesConfig.showGuides() && guidesConfig.hasGuides()) || !assistants.isEmpty();
 
     struct SyncDecorationsWrapperStroke : public KisSimpleStrokeStrategy {
         SyncDecorationsWrapperStroke(KisDocument *document, bool needsDecorationsWrapper)
             : KisSimpleStrokeStrategy(QLatin1String("sync-decorations-wrapper"),
                                       kundo2_noi18n("start-isolated-mode")),
               m_document(document),
               m_needsDecorationsWrapper(needsDecorationsWrapper)
         {
             this->enableJob(JOB_INIT, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
             setClearsRedoOnStart(false);
         }
 
         void initStrokeCallback() override {
             KisDecorationsWrapperLayerSP decorationsLayer =
                 KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(m_document->image()->root());
 
             if (m_needsDecorationsWrapper && !decorationsLayer) {
                 m_document->image()->addNode(new KisDecorationsWrapperLayer(m_document));
             } else if (!m_needsDecorationsWrapper && decorationsLayer) {
                 m_document->image()->removeNode(decorationsLayer);
             }
         }
 
     private:
         KisDocument *m_document = 0;
         bool m_needsDecorationsWrapper = false;
     };
 
     KisStrokeId id = image->startStroke(new SyncDecorationsWrapperStroke(q, needsDecorationsWrapper));
     image->endStroke(id);
 }
 
 void KisDocument::Private::copyFrom(const Private &rhs, KisDocument *q)
 {
     copyFromImpl(rhs, q, KisDocument::REPLACE);
 }
 
 void KisDocument::Private::copyFromImpl(const Private &rhs, KisDocument *q, KisDocument::CopyPolicy policy)
 {
     if (policy == REPLACE) {
         delete docInfo;
     }
     docInfo = (new KoDocumentInfo(*rhs.docInfo, q));
     unit = rhs.unit;
     mimeType = rhs.mimeType;
     outputMimeType = rhs.outputMimeType;
 
     if (policy == REPLACE) {
         q->setGuidesConfig(rhs.guidesConfig);
         q->setMirrorAxisConfig(rhs.mirrorAxisConfig);
         q->setModified(rhs.modified);
         q->setAssistants(KisPaintingAssistant::cloneAssistantList(rhs.assistants));
         q->setGridConfig(rhs.gridConfig);
     } else {
         // in CONSTRUCT mode, we cannot use the functions of KisDocument
         // because KisDocument does not yet have a pointer to us.
         guidesConfig = rhs.guidesConfig;
         mirrorAxisConfig = rhs.mirrorAxisConfig;
         modified = rhs.modified;
         assistants = KisPaintingAssistant::cloneAssistantList(rhs.assistants);
         gridConfig = rhs.gridConfig;
     }
     m_bAutoDetectedMime = rhs.m_bAutoDetectedMime;
     m_url = rhs.m_url;
     m_file = rhs.m_file;
     readwrite = rhs.readwrite;
     firstMod = rhs.firstMod;
     lastMod = rhs.lastMod;
     // XXX: the display properties will be shared between different snapshots
     globalAssistantsColor = rhs.globalAssistantsColor;
     batchMode = rhs.batchMode;
 
     // CHECK THIS! This is what happened to the palette list -- but is it correct here as well? Ask Dmitry!!!
     //    if (policy == REPLACE) {
     //        QList<KoColorSetSP> newPaletteList = clonePaletteList(rhs.paletteList);
     //        q->setPaletteList(newPaletteList, /* emitSignal = */ true);
     //        // we still do not own palettes if we did not
     //    } else {
     //        paletteList = rhs.paletteList;
     //    }
 
     if (rhs.documentResourceStorage) {
         if (policy == REPLACE) {
             // Clone the resources, but don't add them to the database, only the editable
             // version of the document should have those resources in the database.
             documentResourceStorage = rhs.documentResourceStorage->clone();
         }
         else {
             documentResourceStorage = rhs.documentResourceStorage;
         }
     }
 
 }
 
 class KisDocument::Private::StrippedSafeSavingLocker {
 public:
     StrippedSafeSavingLocker(QMutex *savingMutex, KisImageSP image)
         : m_locked(false)
         , m_image(image)
         , m_savingLock(savingMutex)
         , m_imageLock(image, true)
 
     {
         /**
          * Initial try to lock both objects. Locking the image guards
          * us from any image composition threads running in the
          * background, while savingMutex guards us from entering the
          * saving code twice by autosave and main threads.
          *
          * Since we are trying to lock multiple objects, so we should
          * do it in a safe manner.
          */
         m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
 
         if (!m_locked) {
             m_image->requestStrokeEnd();
             QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
 
             // one more try...
             m_locked = std::try_lock(m_imageLock, m_savingLock) < 0;
         }
     }
 
     ~StrippedSafeSavingLocker() {
         if (m_locked) {
             m_imageLock.unlock();
             m_savingLock.unlock();
         }
     }
 
     bool successfullyLocked() const {
         return m_locked;
     }
 
 private:
     bool m_locked;
     KisImageSP m_image;
     StdLockableWrapper<QMutex> m_savingLock;
     KisImageBarrierLockAdapter m_imageLock;
 };
 
 KisDocument::KisDocument(bool addStorage)
     : d(new Private(this))
 {
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
     connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
     connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
     setObjectName(newObjectName());
 
 
     if (addStorage) {
         d->documentResourceStorage.reset(new KisResourceStorage(d->documentStorageID));
         KisResourceLocator::instance()->addStorage(d->documentStorageID, d->documentResourceStorage);
     }
 
     // preload the krita resources
     KisResourceServerProvider::instance();
 
     d->shapeController = new KisShapeController(this, d->nserver);
     d->koShapeController = new KoShapeController(0, d->shapeController);
     d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
 
     slotConfigChanged();
 }
 
 KisDocument::KisDocument(const KisDocument &rhs)
     : QObject(),
       d(new Private(*rhs.d, this))
 {
     copyFromDocumentImpl(rhs, CONSTRUCT);
 }
 
 KisDocument::~KisDocument()
 {
     // wait until all the pending operations are in progress
     waitForSavingToComplete();
 
     /**
      * Push a timebomb, which will try to release the memory after
      * the document has been deleted
      */
     KisPaintDevice::createMemoryReleaseObject()->deleteLater();
 
     d->autoSaveTimer->disconnect(this);
     d->autoSaveTimer->stop();
 
     delete d->importExportManager;
 
     // Despite being QObject they needs to be deleted before the image
     delete d->shapeController;
 
     delete d->koShapeController;
 
     if (d->image) {
         d->image->notifyAboutToBeDeleted();
 
         /**
          * WARNING: We should wait for all the internal image jobs to
          * finish before entering KisImage's destructor. The problem is,
          * while execution of KisImage::~KisImage, all the weak shared
          * pointers pointing to the image enter an inconsistent
          * state(!). The shared counter is already zero and destruction
          * has started, but the weak reference doesn't know about it,
          * because KisShared::~KisShared hasn't been executed yet. So all
          * the threads running in background and having weak pointers will
          * enter the KisImage's destructor as well.
          */
 
         d->image->requestStrokeCancellation();
         d->image->waitForDone();
 
         // clear undo commands that can still point to the image
         d->undoStack->clear();
         d->image->waitForDone();
 
         KisImageWSP sanityCheckPointer = d->image;
         Q_UNUSED(sanityCheckPointer);
 
         // The following line trigger the deletion of the image
         d->image.clear();
 
         // check if the image has actually been deleted
         KIS_SAFE_ASSERT_RECOVER_NOOP(!sanityCheckPointer.isValid());
     }
     if (KisResourceLocator::instance()->hasStorage(d->documentStorageID)) {
         KisResourceLocator::instance()->removeStorage(d->documentStorageID);
     }
 
     delete d;
 }
 
 QString KisDocument::uniqueID() const
 {
     return d->documentStorageID;
 }
 
 KisDocument *KisDocument::clone()
 {
     return new KisDocument(*this);
 }
 
 bool KisDocument::exportDocumentImpl(const KritaUtils::ExportFileJob &job, KisPropertiesConfigurationSP exportConfiguration)
 {
     QFileInfo filePathInfo(job.filePath);
 
     if (filePathInfo.exists() && !filePathInfo.isWritable()) {
         slotCompleteSavingDocument(job, ImportExportCodes::NoAccessToWrite,
                                    i18n("%1 cannot be written to. Please save under a different name.", job.filePath));
         //return ImportExportCodes::NoAccessToWrite;
         return false;
     }
 
     KisConfig cfg(true);
     if (cfg.backupFile() && filePathInfo.exists()) {
 
         QString backupDir;
 
         switch(cfg.readEntry<int>("backupfilelocation", 0)) {
         case 1:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
             break;
         case 2:
             backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
             break;
         default:
             // Do nothing: the empty string is user file location
             break;
         }
 
         int numOfBackupsKept = cfg.readEntry<int>("numberofbackupfiles", 1);
         QString suffix = cfg.readEntry<QString>("backupfilesuffix", "~");
 
         if (numOfBackupsKept == 1) {
             if (!KBackup::simpleBackupFile(job.filePath, backupDir, suffix)) {
                 qWarning() << "Failed to create simple backup file!" << job.filePath << backupDir << suffix;
                 KisUsageLogger::log(QString("Failed to create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
                 return false;
             }
             else {
                 KisUsageLogger::log(QString("Create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
             }
         }
         else if (numOfBackupsKept > 1) {
             if (!KBackup::numberedBackupFile(job.filePath, backupDir, suffix, numOfBackupsKept)) {
                 qWarning() << "Failed to create numbered backup file!" << job.filePath << backupDir << suffix;
                 KisUsageLogger::log(QString("Failed to create a numbered backup for %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
                 return false;
             }
             else {
                 KisUsageLogger::log(QString("Create a simple backup for %1 in %2.").arg(job.filePath).arg(backupDir.isEmpty() ? "the same location as the file" : backupDir));
             }
         }
     }
 
     //KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!job.mimeType.isEmpty(), false);
     if (job.mimeType.isEmpty()) {
 
         KisImportExportErrorCode error = ImportExportCodes::FileFormatIncorrect;
         slotCompleteSavingDocument(job, error, error.errorMessage());
         return false;
 
     }
 
     const QString actionName =
         job.flags & KritaUtils::SaveIsExporting ?
         i18n("Exporting Document...") :
         i18n("Saving Document...");
 
     bool started =
         initiateSavingInBackground(actionName,
                                    this, SLOT(slotCompleteSavingDocument(KritaUtils::ExportFileJob, KisImportExportErrorCode ,QString)),
                                    job, exportConfiguration);
     if (!started) {
         emit canceled(QString());
     }
 
     return started;
 }
 
 bool KisDocument::exportDocument(const QUrl &url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     SaveFlags flags = SaveIsExporting;
     if (showWarnings) {
         flags |= SaveShowWarnings;
     }
 
     KisUsageLogger::log(QString("Exporting Document: %1 as %2. %3 * %4 pixels, %5 layers, %6 frames, %7 framerate. Export configuration: %8")
                         .arg(url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration"));
 
     return exportDocumentImpl(KritaUtils::ExportFileJob(url.toLocalFile(),
                                                         mimeType,
                                                         flags),
                               exportConfiguration);
 
 }
 
 bool KisDocument::saveAs(const QUrl &_url, const QByteArray &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     using namespace KritaUtils;
 
     KisUsageLogger::log(QString("Saving Document %9 as %1 (mime: %2). %3 * %4 pixels, %5 layers.  %6 frames, %7 framerate. Export configuration: %8")
                         .arg(_url.toLocalFile())
                         .arg(QString::fromLatin1(mimeType))
                         .arg(d->image->width())
                         .arg(d->image->height())
                         .arg(d->image->nlayers())
                         .arg(d->image->animationInterface()->totalLength())
                         .arg(d->image->animationInterface()->framerate())
                         .arg(exportConfiguration ? exportConfiguration->toXML() : "No configuration")
                         .arg(url().toLocalFile()));
 
 
     return exportDocumentImpl(ExportFileJob(_url.toLocalFile(),
                                             mimeType,
                                             showWarnings ? SaveShowWarnings : SaveNone),
                               exportConfiguration);
 }
 
 bool KisDocument::save(bool showWarnings, KisPropertiesConfigurationSP exportConfiguration)
 {
     return saveAs(url(), mimeType(), showWarnings, exportConfiguration);
 }
 
 QByteArray KisDocument::serializeToNativeByteArray()
 {
     QByteArray byteArray;
     QBuffer buffer(&byteArray);
 
     QScopedPointer<KisImportExportFilter> filter(KisImportExportManager::filterForMimeType(nativeFormatMimeType(), KisImportExportManager::Export));
     filter->setBatchMode(true);
     filter->setMimeType(nativeFormatMimeType());
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return byteArray;
     }
 
     d->savingImage = d->image;
 
     if (!filter->convert(this, &buffer).isOk()) {
         qWarning() << "serializeToByteArray():: Could not export to our native format";
     }
 
     return byteArray;
 }
 
 void KisDocument::slotCompleteSavingDocument(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     if (status.isCancelled())
         return;
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during saving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
 
         if (!fileBatchMode()) {
             const QString filePath = job.filePath;
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not save %1\nReason: %2", filePath, exportErrorToUserMessage(status, errorMessage)));
         }
     } else {
         if (!(job.flags & KritaUtils::SaveIsExporting)) {
             const QString existingAutoSaveBaseName = localFilePath();
             const bool wasRecovered = isRecovered();
 
             setUrl(QUrl::fromLocalFile(job.filePath));
             setLocalFilePath(job.filePath);
             setMimeType(job.mimeType);
             updateEditingTime(true);
 
             if (!d->modifiedWhileSaving) {
                 /**
                  * If undo stack is already clean/empty, it doesn't emit any
                  * signals, so we might forget update document modified state
                  * (which was set, e.g. while recovering an autosave file)
                  */
 
                 if (d->undoStack->isClean()) {
                     setModified(false);
                 } else {
                     d->undoStack->setClean();
                 }
             }
             setRecovered(false);
             removeAutoSaveFiles(existingAutoSaveBaseName, wasRecovered);
         }
 
         emit completed();
         emit sigSavingFinished();
 
         emit statusBarMessage(i18n("Finished saving %1", fileName), successMessageTimeout);
     }
 }
 
 QByteArray KisDocument::mimeType() const
 {
     return d->mimeType;
 }
 
 void KisDocument::setMimeType(const QByteArray & mimeType)
 {
     d->mimeType = mimeType;
 }
 
 bool KisDocument::fileBatchMode() const
 {
     return d->batchMode;
 }
 
 void KisDocument::setFileBatchMode(const bool batchMode)
 {
     d->batchMode = batchMode;
 }
 
 KisDocument* KisDocument::lockAndCloneForSaving()
 {
     // force update of all the asynchronous nodes before cloning
     QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
     KisLayerUtils::forceAllDelayedNodesUpdate(d->image->root());
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             if (!window->viewManager()->blockUntilOperationsFinished(d->image)) {
                 return 0;
             }
         }
     }
 
     Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
     if (!locker.successfullyLocked()) {
         return 0;
     }
 
     return new KisDocument(*this);
 }
 
 KisDocument *KisDocument::lockAndCreateSnapshot()
 {
     KisDocument *doc = lockAndCloneForSaving();
     if (doc) {
         // clone the local resource storage and its contents -- that is, the old palette list
         if (doc->d->documentResourceStorage) {
             doc->d->documentResourceStorage = doc->d->documentResourceStorage->clone();
         }
     }
     return doc;
 }
 
 void KisDocument::copyFromDocument(const KisDocument &rhs)
 {
     copyFromDocumentImpl(rhs, REPLACE);
 }
 
 void KisDocument::copyFromDocumentImpl(const KisDocument &rhs, CopyPolicy policy)
 {
     if (policy == REPLACE) {
         d->copyFrom(*(rhs.d), this);
 
         d->undoStack->clear();
     } else {
         // in CONSTRUCT mode, d should be already initialized
         connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(slotConfigChanged()));
         connect(d->undoStack, SIGNAL(cleanChanged(bool)), this, SLOT(slotUndoStackCleanChanged(bool)));
         connect(d->autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
 
         d->shapeController = new KisShapeController(this, d->nserver);
         d->koShapeController = new KoShapeController(0, d->shapeController);
         d->shapeController->resourceManager()->setGlobalShapeController(d->koShapeController);
     }
 
     setObjectName(rhs.objectName());
 
     slotConfigChanged();
 
     if (rhs.d->image) {
         if (policy == REPLACE) {
             d->image->barrierLock(/* readOnly = */ false);
             rhs.d->image->barrierLock(/* readOnly = */ true);
             d->image->copyFromImage(*(rhs.d->image));
             d->image->unlock();
             rhs.d->image->unlock();
             setCurrentImage(d->image, /* forceInitialUpdate = */ true);
         } else {
             // clone the image with keeping the GUIDs of the layers intact
             // NOTE: we expect the image to be locked!
             setCurrentImage(rhs.image()->clone(/* exactCopy = */ true), /* forceInitialUpdate = */ false);
         }
     }
 
     if (rhs.d->preActivatedNode) {
         QQueue<KisNodeSP> linearizedNodes;
         KisLayerUtils::recursiveApplyNodes(rhs.d->image->root(),
                                            [&linearizedNodes](KisNodeSP node) {
                                                linearizedNodes.enqueue(node);
                                            });
         KisLayerUtils::recursiveApplyNodes(d->image->root(),
                                            [&linearizedNodes, &rhs, this](KisNodeSP node) {
                                                KisNodeSP refNode = linearizedNodes.dequeue();
                                                if (rhs.d->preActivatedNode.data() == refNode.data()) {
                                                    d->preActivatedNode = node;
                                                }
                                            });
     }
 
     // reinitialize references' signal connection
     KisReferenceImagesLayerSP referencesLayer = this->referenceImagesLayer();
     setReferenceImagesLayer(referencesLayer, false);
 
     KisDecorationsWrapperLayerSP decorationsLayer =
         KisLayerUtils::findNodeByType<KisDecorationsWrapperLayer>(d->image->root());
     if (decorationsLayer) {
         decorationsLayer->setDocument(this);
     }
 
 
     if (policy == REPLACE) {
         setModified(true);
     }
 }
 
 bool KisDocument::exportDocumentSync(const QUrl &url, const QByteArray &mimeType, KisPropertiesConfigurationSP exportConfiguration)
 {
     {
 
         /**
          * The caller guarantees that no one else uses the document (usually,
          * it is a temporary document created specifically for exporting), so
          * we don't need to copy or lock the document. Instead we should just
          * ensure the barrier lock is synced and then released.
          */
         Private::StrippedSafeSavingLocker locker(&d->savingMutex, d->image);
         if (!locker.successfullyLocked()) {
             return false;
         }
     }
 
     d->savingImage = d->image;
 
     const QString fileName = url.toLocalFile();
 
     KisImportExportErrorCode status =
             d->importExportManager->
             exportDocument(fileName, fileName, mimeType, false, exportConfiguration);
 
     d->savingImage = 0;
 
     return status.isOk();
 }
 
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration)
 {
     return initiateSavingInBackground(actionName, receiverObject, receiverMethod,
                                       job, exportConfiguration, std::unique_ptr<KisDocument>());
 }
 
 bool KisDocument::initiateSavingInBackground(const QString actionName,
                                              const QObject *receiverObject, const char *receiverMethod,
                                              const KritaUtils::ExportFileJob &job,
                                              KisPropertiesConfigurationSP exportConfiguration,
                                              std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     KIS_ASSERT_RECOVER_RETURN_VALUE(job.isValid(), false);
 
     QScopedPointer<KisDocument> clonedDocument;
 
     if (!optionalClonedDocument) {
         clonedDocument.reset(lockAndCloneForSaving());
     } else {
         clonedDocument.reset(optionalClonedDocument.release());
     }
 
     // we block saving until the current saving is finished!
     if (!clonedDocument || !d->savingMutex.tryLock()) {
         return false;
     }
 
     auto waitForImage = [] (KisImageSP image) {
         KisMainWindow *window = KisPart::instance()->currentMainwindow();
         if (window) {
             if (window->viewManager()) {
                 window->viewManager()->blockUntilOperationsFinishedForced(image);
             }
         }
     };
 
     {
         KisNodeSP newRoot = clonedDocument->image()->root();
         KIS_SAFE_ASSERT_RECOVER(!KisLayerUtils::hasDelayedNodeWithUpdates(newRoot)) {
             KisLayerUtils::forceAllDelayedNodesUpdate(newRoot);
             waitForImage(clonedDocument->image());
         }
     }
 
     if (clonedDocument->image()->hasOverlaySelectionMask()) {
         clonedDocument->image()->setOverlaySelectionMask(0);
         waitForImage(clonedDocument->image());
     }
 
     KisConfig cfg(true);
     if (cfg.trimKra()) {
         clonedDocument->image()->cropImage(clonedDocument->image()->bounds());
         clonedDocument->image()->purgeUnusedData(false);
         waitForImage(clonedDocument->image());
     }
 
     KIS_SAFE_ASSERT_RECOVER(clonedDocument->image()->isIdle()) {
         waitForImage(clonedDocument->image());
     }
 
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveDocument, false);
     KIS_ASSERT_RECOVER_RETURN_VALUE(!d->backgroundSaveJob.isValid(), false);
     d->backgroundSaveDocument.reset(clonedDocument.take());
     d->backgroundSaveJob = job;
     d->modifiedWhileSaving = false;
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = true;
     }
 
     connect(d->backgroundSaveDocument.data(),
             SIGNAL(sigBackgroundSavingFinished(KisImportExportErrorCode, QString)),
             this,
             SLOT(slotChildCompletedSavingInBackground(KisImportExportErrorCode, QString)));
 
 
     connect(this, SIGNAL(sigCompleteBackgroundSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString)),
             receiverObject, receiverMethod, Qt::UniqueConnection);
 
     bool started =
             d->backgroundSaveDocument->startExportInBackground(actionName,
                                                                job.filePath,
                                                                job.filePath,
                                                                job.mimeType,
                                                                job.flags & KritaUtils::SaveShowWarnings,
                                                                exportConfiguration);
 
     if (!started) {
         // the state should have been deinitialized in slotChildCompletedSavingInBackground()
 
         KIS_SAFE_ASSERT_RECOVER (!d->backgroundSaveDocument && !d->backgroundSaveJob.isValid()) {
             d->backgroundSaveDocument.take()->deleteLater();
             d->savingMutex.unlock();
             d->backgroundSaveJob = KritaUtils::ExportFileJob();
         }
     }
 
     return started;
 }
 
 
 void KisDocument::slotChildCompletedSavingInBackground(KisImportExportErrorCode status, const QString &errorMessage)
 {
     KIS_ASSERT_RECOVER_RETURN(isSaving());
 
     KIS_ASSERT_RECOVER(d->backgroundSaveDocument) {
         d->savingMutex.unlock();
         return;
     }
 
     if (d->backgroundSaveJob.flags & KritaUtils::SaveInAutosaveMode) {
         d->backgroundSaveDocument->d->isAutosaving = false;
     }
 
     d->backgroundSaveDocument.take()->deleteLater();
 
     KIS_ASSERT_RECOVER(d->backgroundSaveJob.isValid()) {
         d->savingMutex.unlock();
         return;
     }
 
     const KritaUtils::ExportFileJob job = d->backgroundSaveJob;
     d->backgroundSaveJob = KritaUtils::ExportFileJob();
 
     // unlock at the very end
     d->savingMutex.unlock();
 
 
     QFileInfo fi(job.filePath);
     KisUsageLogger::log(QString("Completed saving %1 (mime: %2). Result: %3. Size: %4. MD5 Hash: %5")
                         .arg(job.filePath)
                         .arg(QString::fromLatin1(job.mimeType))
                         .arg(!status.isOk() ? exportErrorToUserMessage(status, errorMessage) : "OK")
                         .arg(fi.size())
                         .arg(fi.size() > 10000000 ? "FILE_BIGGER_10MB" : QString::fromLatin1(KoMD5Generator().generateHash(job.filePath).toHex())));
 
     emit sigCompleteBackgroundSaving(job, status, errorMessage);
 }
 
 void KisDocument::slotAutoSaveImpl(std::unique_ptr<KisDocument> &&optionalClonedDocument)
 {
     if (!d->modified || !d->modifiedAfterAutosave) return;
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     emit statusBarMessage(i18n("Autosaving... %1", autoSaveFileName), successMessageTimeout);
 
     KisUsageLogger::log(QString("Autosaving: %1").arg(autoSaveFileName));
 
     const bool hadClonedDocument = bool(optionalClonedDocument);
     bool started = false;
 
     if (d->image->isIdle() || hadClonedDocument) {
         started = initiateSavingInBackground(i18n("Autosaving..."),
                                              this, SLOT(slotCompleteAutoSaving(KritaUtils::ExportFileJob, KisImportExportErrorCode, QString)),
                                              KritaUtils::ExportFileJob(autoSaveFileName, nativeFormatMimeType(), KritaUtils::SaveIsExporting | KritaUtils::SaveInAutosaveMode),
                                              0,
                                              std::move(optionalClonedDocument));
     } else {
         emit statusBarMessage(i18n("Autosaving postponed: document is busy..."), errorMessageTimeout);
     }
 
     if (!started && !hadClonedDocument && d->autoSaveFailureCount >= 3) {
         KisCloneDocumentStroke *stroke = new KisCloneDocumentStroke(this);
         connect(stroke, SIGNAL(sigDocumentCloned(KisDocument*)),
                 this, SLOT(slotInitiateAsyncAutosaving(KisDocument*)),
                 Qt::BlockingQueuedConnection);
 
         KisStrokeId strokeId = d->image->startStroke(stroke);
         d->image->endStroke(strokeId);
 
         setInfiniteAutoSaveInterval();
 
     } else if (!started) {
         setEmergencyAutoSaveInterval();
     } else {
         d->modifiedAfterAutosave = false;
     }
 }
 
 void KisDocument::slotAutoSave()
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>());
 }
 
 void KisDocument::slotInitiateAsyncAutosaving(KisDocument *clonedDocument)
 {
     slotAutoSaveImpl(std::unique_ptr<KisDocument>(clonedDocument));
 }
 
 void KisDocument::slotPerformIdleRoutines()
 {
     d->image->explicitRegenerateLevelOfDetail();
 
 
     /// TODO: automatical purging is disabled for now: it modifies
     ///       data managers without creating a transaction, which breaks
     ///       undo.
 
     // d->image->purgeUnusedData(true);
 }
 
 void KisDocument::slotCompleteAutoSaving(const KritaUtils::ExportFileJob &job, KisImportExportErrorCode status, const QString &errorMessage)
 {
     Q_UNUSED(job);
 
     const QString fileName = QFileInfo(job.filePath).fileName();
 
     if (!status.isOk()) {
         setEmergencyAutoSaveInterval();
         emit statusBarMessage(i18nc("%1 --- failing file name, %2 --- error message",
                                     "Error during autosaving %1: %2",
                                     fileName,
                                     exportErrorToUserMessage(status, errorMessage)), errorMessageTimeout);
     } else {
         KisConfig cfg(true);
         d->autoSaveDelay = cfg.autoSaveInterval();
 
         if (!d->modifiedWhileSaving) {
             d->autoSaveTimer->stop(); // until the next change
             d->autoSaveFailureCount = 0;
         } else {
             setNormalAutoSaveInterval();
         }
 
         emit statusBarMessage(i18n("Finished autosaving %1", fileName), successMessageTimeout);
     }
 }
 
 bool KisDocument::startExportInBackground(const QString &actionName,
                                           const QString &location,
                                           const QString &realLocation,
                                           const QByteArray &mimeType,
                                           bool showWarnings,
                                           KisPropertiesConfigurationSP exportConfiguration)
 {
     d->savingImage = d->image;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     if (window) {
         if (window->viewManager()) {
             d->savingUpdater = window->viewManager()->createThreadedUpdater(actionName);
             d->importExportManager->setUpdater(d->savingUpdater);
         }
     }
 
     KisImportExportErrorCode initializationStatus(ImportExportCodes::OK);
     d->childSavingFuture =
             d->importExportManager->exportDocumentAsyc(location,
                                                        realLocation,
                                                        mimeType,
                                                        initializationStatus,
                                                        showWarnings,
                                                        exportConfiguration);
 
     if (!initializationStatus.isOk()) {
         if (d->savingUpdater) {
             d->savingUpdater->cancel();
         }
         d->savingImage.clear();
         emit sigBackgroundSavingFinished(initializationStatus, initializationStatus.errorMessage());
         return false;
     }
 
     typedef QFutureWatcher<KisImportExportErrorCode> StatusWatcher;
     StatusWatcher *watcher = new StatusWatcher();
     watcher->setFuture(d->childSavingFuture);
 
     connect(watcher, SIGNAL(finished()), SLOT(finishExportInBackground()));
     connect(watcher, SIGNAL(finished()), watcher, SLOT(deleteLater()));
 
     return true;
 }
 
 void KisDocument::finishExportInBackground()
 {
     KIS_SAFE_ASSERT_RECOVER(d->childSavingFuture.isFinished()) {
         emit sigBackgroundSavingFinished(ImportExportCodes::InternalError, "");
         return;
     }
 
    KisImportExportErrorCode status =
             d->childSavingFuture.result();
     const QString errorMessage = status.errorMessage();
 
     d->savingImage.clear();
     d->childSavingFuture = QFuture<KisImportExportErrorCode>();
     d->lastErrorMessage.clear();
 
     if (d->savingUpdater) {
         d->savingUpdater->setProgress(100);
     }
 
     emit sigBackgroundSavingFinished(status, errorMessage);
 }
 
 void KisDocument::setReadWrite(bool readwrite)
 {
     d->readwrite = readwrite;
     setNormalAutoSaveInterval();
 
     Q_FOREACH (KisMainWindow *mainWindow, KisPart::instance()->mainWindows()) {
         mainWindow->setReadWrite(readwrite);
     }
 }
 
 void KisDocument::setAutoSaveDelay(int delay)
 {
     if (isReadWrite() && delay > 0) {
         d->autoSaveTimer->start(delay * 1000);
     } else {
         d->autoSaveTimer->stop();
     }
 }
 
 void KisDocument::setNormalAutoSaveInterval()
 {
     setAutoSaveDelay(d->autoSaveDelay);
     d->autoSaveFailureCount = 0;
 }
 
 void KisDocument::setEmergencyAutoSaveInterval()
 {
     const int emergencyAutoSaveInterval = 10; /* sec */
     setAutoSaveDelay(emergencyAutoSaveInterval);
     d->autoSaveFailureCount++;
 }
 
 void KisDocument::setInfiniteAutoSaveInterval()
 {
     setAutoSaveDelay(-1);
 }
 
 KoDocumentInfo *KisDocument::documentInfo() const
 {
     return d->docInfo;
 }
 
 bool KisDocument::isModified() const
 {
     return d->modified;
 }
 
 QPixmap KisDocument::generatePreview(const QSize& size)
 {
     KisImageSP image = d->image;
     if (d->savingImage) image = d->savingImage;
 
     if (image) {
         QRect bounds = image->bounds();
         QSize newSize = bounds.size();
         newSize.scale(size, Qt::KeepAspectRatio);
         QPixmap px = QPixmap::fromImage(image->convertToQImage(newSize, 0));
         if (px.size() == QSize(0,0)) {
             px = QPixmap(newSize);
             QPainter gc(&px);
             QBrush checkBrush = QBrush(KisCanvasWidgetBase::createCheckersImage(newSize.width() / 5));
             gc.fillRect(px.rect(), checkBrush);
             gc.end();
         }
         return px;
     }
     return QPixmap(size);
 }
 
 QString KisDocument::generateAutoSaveFileName(const QString & path) const
 {
     QString retval;
 
     // Using the extension allows to avoid relying on the mime magic when opening
     const QString extension (".kra");
     QString prefix = KisConfig(true).readEntry<bool>("autosavefileshidden") ? QString(".") : QString();
     QRegularExpression autosavePattern1("^\\..+-autosave.kra$");
     QRegularExpression autosavePattern2("^.+-autosave.kra$");
 
     QFileInfo fi(path);
     QString dir = fi.absolutePath();
     QString filename = fi.fileName();
 
     if (path.isEmpty() || autosavePattern1.match(filename).hasMatch() || autosavePattern2.match(filename).hasMatch() || !fi.isWritable()) {
         // Never saved?
 #ifdef Q_OS_WIN
         // On Windows, use the temp location (https://bugs.kde.org/show_bug.cgi?id=314921)
         retval = QString("%1%2%7%3-%4-%5-autosave%6").arg(QDir::tempPath()).arg('/').arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #else
         // On Linux, use a temp file in $HOME then. Mark it with the pid so two instances don't overwrite each other's autosave file
         retval = QString("%1%2%7%3-%4-%5-autosave%6").arg(QDir::homePath()).arg('/').arg("krita").arg(qApp->applicationPid()).arg(objectName()).arg(extension).arg(prefix);
 #endif
     } else {
         retval = QString("%1%2%5%3-autosave%4").arg(dir).arg('/').arg(filename).arg(extension).arg(prefix);
     }
 
     //qDebug() << "generateAutoSaveFileName() for path" << path << ":" << retval;
     return retval;
 }
 
 bool KisDocument::importDocument(const QUrl &_url)
 {
     bool ret;
 
     dbgUI << "url=" << _url.url();
 
     // open...
     ret = openUrl(_url);
 
     // reset url & m_file (kindly? set by KisParts::openUrl()) to simulate a
     // File --> Import
     if (ret) {
         dbgUI << "success, resetting url";
         resetURL();
         setTitleModified();
     }
 
     return ret;
 }
 
 
 bool KisDocument::openUrl(const QUrl &_url, OpenFlags flags)
 {
     if (!_url.isLocalFile()) {
         return false;
     }
     dbgUI << "url=" << _url.url();
     d->lastErrorMessage.clear();
 
     // Reimplemented, to add a check for autosave files and to improve error reporting
     if (!_url.isValid()) {
         d->lastErrorMessage = i18n("Malformed URL\n%1", _url.url());  // ## used anywhere ?
         return false;
     }
 
     QUrl url(_url);
     QString original  = "";
     bool autosaveOpened = false;
     if (url.isLocalFile() && !fileBatchMode()) {
         QString file = url.toLocalFile();
         QString asf = generateAutoSaveFileName(file);
         if (QFile::exists(asf)) {
             KisApplication *kisApp = static_cast<KisApplication*>(qApp);
             kisApp->hideSplashScreen();
             //qDebug() <<"asf=" << asf;
             // ## TODO compare timestamps ?
             KisRecoverNamedAutosaveDialog dlg(0, file, asf);
             dlg.exec();
             int res = dlg.result();
 
             switch (res) {
             case KisRecoverNamedAutosaveDialog::OpenAutosave :
                 original = file;
                 url.setPath(asf);
                 autosaveOpened = true;
                 break;
             case KisRecoverNamedAutosaveDialog::OpenMainFile :
                 KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
                 QFile::remove(asf);
                 break;
             default: // Cancel
                 return false;
             }
         }
     }
 
     bool ret = openUrlInternal(url);
 
     if (autosaveOpened || flags & RecoveryFile) {
         setReadWrite(true); // enable save button
         setModified(true);
         setRecovered(true);
 
         setUrl(QUrl::fromLocalFile(original)); // since it was an autosave, it will be a local file
         setLocalFilePath(original);
     }
     else {
         if (ret) {
 
             if (!(flags & DontAddToRecent)) {
                 KisPart::instance()->addRecentURLToAllMainWindows(_url);
             }
 
             // Detect readonly local-files; remote files are assumed to be writable
             QFileInfo fi(url.toLocalFile());
             setReadWrite(fi.isWritable());
         }
 
         setRecovered(false);
     }
 
     return ret;
 }
 
 class DlgLoadMessages : public KoDialog {
 public:
     DlgLoadMessages(const QString &title, const QString &message, const QStringList &warnings) {
         setWindowTitle(title);
         setWindowIcon(KisIconUtils::loadIcon("warning"));
         QWidget *page = new QWidget(this);
         QVBoxLayout *layout = new QVBoxLayout(page);
         QHBoxLayout *hlayout = new QHBoxLayout();
         QLabel *labelWarning= new QLabel();
         labelWarning->setPixmap(KisIconUtils::loadIcon("warning").pixmap(32, 32));
         hlayout->addWidget(labelWarning);
         hlayout->addWidget(new QLabel(message));
         layout->addLayout(hlayout);
         QTextBrowser *browser = new QTextBrowser();
         QString warning = "<html><body><p><b>";
         if (warnings.size() == 1) {
             warning += "</b> Reason:</p>";
         }
         else {
             warning += "</b> Reasons:</p>";
         }
         warning += "<p/><ul>";
 
         Q_FOREACH(const QString &w, warnings) {
             warning += "\n<li>" + w + "</li>";
         }
         warning += "</ul>";
         browser->setHtml(warning);
         browser->setMinimumHeight(200);
         browser->setMinimumWidth(400);
         layout->addWidget(browser);
         setMainWidget(page);
         setButtons(KoDialog::Ok);
         resize(minimumSize());
     }
 };
 
 bool KisDocument::openFile()
 {
     //dbgUI <<"for" << localFilePath();
     if (!QFile::exists(localFilePath()) && !fileBatchMode()) {
         QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("File %1 does not exist.", localFilePath()));
         return false;
     }
 
     QString filename = localFilePath();
     QString typeName = mimeType();
 
     if (typeName.isEmpty()) {
         typeName = KisMimeDatabase::mimeTypeForFile(filename);
     }
 
     //qDebug() << "mimetypes 4:" << typeName;
 
     // Allow to open backup files, don't keep the mimetype application/x-trash.
     if (typeName == "application/x-trash") {
         QString path = filename;
         while (path.length() > 0) {
             path.chop(1);
             typeName = KisMimeDatabase::mimeTypeForFile(path);
             //qDebug() << "\t" << path << typeName;
             if (!typeName.isEmpty()) {
                 break;
             }
         }
         //qDebug() << "chopped" << filename  << "to" << path << "Was trash, is" << typeName;
     }
     dbgUI << localFilePath() << "type:" << typeName;
 
     KisMainWindow *window = KisPart::instance()->currentMainwindow();
     KoUpdaterPtr updater;
     if (window && window->viewManager()) {
         updater = window->viewManager()->createUnthreadedUpdater(i18n("Opening document"));
         d->importExportManager->setUpdater(updater);
     }
 
     KisImportExportErrorCode status = d->importExportManager->importDocument(localFilePath(), typeName);
 
     if (!status.isOk()) {
         if (window && window->viewManager()) {
             updater->cancel();
         }
         QString msg = status.errorMessage();
         if (!msg.isEmpty() && !fileBatchMode()) {
             DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                                 i18n("Could not open %2.\nReason: %1.", msg, prettyPathOrUrl()),
                                 errorMessage().split("\n") + warningMessage().split("\n"));
             dlg.exec();
         }
         return false;
     }
     else if (!warningMessage().isEmpty() && !fileBatchMode()) {
         DlgLoadMessages dlg(i18nc("@title:window", "Krita"),
                             i18n("There were problems opening %1.", prettyPathOrUrl()),
                             warningMessage().split("\n"));
         dlg.exec();
         setUrl(QUrl());
     }
 
     setMimeTypeAfterLoading(typeName);
     d->syncDecorationsWrapperLayerState();
     emit sigLoadingFinished();
 
     undoStack()->clear();
 
     return true;
 }
 
 void KisDocument::autoSaveOnPause()
 {
     if (!d->modified || !d->modifiedAfterAutosave)
         return;
 
     const QString autoSaveFileName = generateAutoSaveFileName(localFilePath());
 
     QUrl url("file:/" + autoSaveFileName);
     bool started = exportDocumentSync(url, nativeFormatMimeType());
 
     if (started)
     {
         d->modifiedAfterAutosave = false;
         dbgAndroid << "autoSaveOnPause successful";
     }
     else
     {
         qWarning() << "Could not auto-save when paused";
     }
 }
 
 // shared between openFile and koMainWindow's "create new empty document" code
 void KisDocument::setMimeTypeAfterLoading(const QString& mimeType)
 {
     d->mimeType = mimeType.toLatin1();
     d->outputMimeType = d->mimeType;
 }
 
 
 bool KisDocument::loadNativeFormat(const QString & file_)
 {
     return openUrl(QUrl::fromLocalFile(file_));
 }
 
 void KisDocument::setModified(bool mod)
 {
     if (mod) {
         updateEditingTime(false);
     }
 
     if (d->isAutosaving)   // ignore setModified calls due to autosaving
         return;
 
     if ( !d->readwrite && d->modified ) {
         errKrita << "Can't set a read-only document to 'modified' !" << endl;
         return;
     }
 
     //dbgUI<<" url:" << url.path();
     //dbgUI<<" mod="<<mod<<" MParts mod="<<KisParts::ReadWritePart::isModified()<<" isModified="<<isModified();
 
     if (mod && !d->autoSaveTimer->isActive()) {
         // First change since last autosave -> start the autosave timer
         setNormalAutoSaveInterval();
     }
     d->modifiedAfterAutosave = mod;
     d->modifiedWhileSaving = mod;
 
     if (mod == isModified())
         return;
 
     d->modified = mod;
 
     if (mod) {
         documentInfo()->updateParameters();
     }
 
     // This influences the title
     setTitleModified();
     emit modified(mod);
 }
 
 void KisDocument::setRecovered(bool value)
 {
     d->isRecovered = value;
 }
 
 bool KisDocument::isRecovered() const
 {
     return d->isRecovered;
 }
 
 void KisDocument::updateEditingTime(bool forceStoreElapsed)
 {
     QDateTime now = QDateTime::currentDateTime();
     int firstModDelta = d->firstMod.secsTo(now);
     int lastModDelta = d->lastMod.secsTo(now);
 
     if (lastModDelta > 30) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + d->firstMod.secsTo(d->lastMod)));
         d->firstMod = now;
     } else if (firstModDelta > 60 || forceStoreElapsed) {
         d->docInfo->setAboutInfo("editing-time", QString::number(d->docInfo->aboutInfo("editing-time").toInt() + firstModDelta));
         d->firstMod = now;
     }
 
     d->lastMod = now;
 }
 
 QString KisDocument::prettyPathOrUrl() const
 {
     QString _url(url().toDisplayString());
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         _url = QDir::toNativeSeparators(_url);
     }
 #endif
     return _url;
 }
 
 // Get caption from document info (title(), in about page)
 QString KisDocument::caption() const
 {
     QString c;
     const QString _url(url().fileName());
 
     // if URL is empty...it is probably an unsaved file
     if (_url.isEmpty()) {
         c = " [" + i18n("Not Saved") + "] ";
     } else {
         c = _url; // Fall back to document URL
     }
 
     return c;
 }
 
 void KisDocument::setTitleModified()
 {
     emit titleModified(caption(), isModified());
 }
 
 QDomDocument KisDocument::createDomDocument(const QString& tagName, const QString& version) const
 {
     return createDomDocument("krita", tagName, version);
 }
 
 //static
 QDomDocument KisDocument::createDomDocument(const QString& appName, const QString& tagName, const QString& version)
 {
     QDomImplementation impl;
     QString url = QString("http://www.calligra.org/DTD/%1-%2.dtd").arg(appName).arg(version);
     QDomDocumentType dtype = impl.createDocumentType(tagName,
                                                      QString("-//KDE//DTD %1 %2//EN").arg(appName).arg(version),
                                                      url);
     // The namespace URN doesn't need to include the version number.
     QString namespaceURN = QString("http://www.calligra.org/DTD/%1").arg(appName);
     QDomDocument doc = impl.createDocument(namespaceURN, tagName, dtype);
     doc.insertBefore(doc.createProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\""), doc.documentElement());
     return doc;
 }
 
 bool KisDocument::isNativeFormat(const QByteArray& mimetype) const
 {
     if (mimetype == nativeFormatMimeType())
         return true;
     return extraNativeMimeTypes().contains(mimetype);
 }
 
 void KisDocument::setErrorMessage(const QString& errMsg)
 {
     d->lastErrorMessage = errMsg;
 }
 
 QString KisDocument::errorMessage() const
 {
     return d->lastErrorMessage;
 }
 
 void KisDocument::setWarningMessage(const QString& warningMsg)
 {
     d->lastWarningMessage = warningMsg;
 }
 
 QString KisDocument::warningMessage() const
 {
     return d->lastWarningMessage;
 }
 
 
 void KisDocument::removeAutoSaveFiles(const QString &autosaveBaseName, bool wasRecovered)
 {
     // Eliminate any auto-save file
     QString asf = generateAutoSaveFileName(autosaveBaseName);   // the one in the current dir
     if (QFile::exists(asf)) {
         KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
         QFile::remove(asf);
     }
     asf = generateAutoSaveFileName(QString());   // and the one in $HOME
 
     if (QFile::exists(asf)) {
         KisUsageLogger::log(QString("Removing autosave file: %1").arg(asf));
         QFile::remove(asf);
     }
 
     QList<QRegularExpression> expressions;
 
     expressions << QRegularExpression("^\\..+-autosave.kra$")
                 << QRegularExpression("^.+-autosave.kra$");
 
     Q_FOREACH(const QRegularExpression &rex, expressions) {
         if (wasRecovered &&
                 !autosaveBaseName.isEmpty() &&
                 rex.match(QFileInfo(autosaveBaseName).fileName()).hasMatch() &&
                 QFile::exists(autosaveBaseName)) {
 
             KisUsageLogger::log(QString("Removing autosave file: %1").arg(autosaveBaseName));
             QFile::remove(autosaveBaseName);
         }
     }
 }
 
 KoUnit KisDocument::unit() const
 {
     return d->unit;
 }
 
 void KisDocument::setUnit(const KoUnit &unit)
 {
     if (d->unit != unit) {
         d->unit = unit;
         emit unitChanged(unit);
     }
 }
 
 KUndo2Stack *KisDocument::undoStack()
 {
     return d->undoStack;
 }
 
 KisImportExportManager *KisDocument::importExportManager() const
 {
     return d->importExportManager;
 }
 
 void KisDocument::addCommand(KUndo2Command *command)
 {
     if (command)
         d->undoStack->push(command);
 }
 
 void KisDocument::beginMacro(const KUndo2MagicString & text)
 {
     d->undoStack->beginMacro(text);
 }
 
 void KisDocument::endMacro()
 {
     d->undoStack->endMacro();
 }
 
 void KisDocument::slotUndoStackCleanChanged(bool value)
 {
     setModified(!value);
 }
 
 void KisDocument::slotConfigChanged()
 {
     KisConfig cfg(true);
 
     if (d->undoStack->undoLimit() != cfg.undoStackLimit()) {
         if (!d->undoStack->isClean()) {
             d->undoStack->clear();
         }
         d->undoStack->setUndoLimit(cfg.undoStackLimit());
     }
 
     d->autoSaveDelay = cfg.autoSaveInterval();
     setNormalAutoSaveInterval();
 }
 
 void KisDocument::slotImageRootChanged()
 {
     d->syncDecorationsWrapperLayerState();
 }
 
 void KisDocument::clearUndoHistory()
 {
     d->undoStack->clear();
 }
 
 KisGridConfig KisDocument::gridConfig() const
 {
     return d->gridConfig;
 }
 
 void KisDocument::setGridConfig(const KisGridConfig &config)
 {
     if (d->gridConfig != config) {
         d->gridConfig = config;
         d->syncDecorationsWrapperLayerState();
         emit sigGridConfigChanged(config);
     }
 }
 
 QList<KoColorSetSP > KisDocument::paletteList()
 {
     qDebug() << "PALETTELIST storage" << d->documentResourceStorage;
 
     QList<KoColorSetSP> _paletteList;
     if (d->documentResourceStorage.isNull()) {
         qWarning() << "No documentstorage for palettes";
         return _paletteList;
     }
 
     QSharedPointer<KisResourceStorage::ResourceIterator> iter = d->documentResourceStorage->resources(ResourceType::Palettes);
     while (iter->hasNext()) {
         iter->next();
         KoResourceSP resource = iter->resource();
         if (resource && resource->valid()) {
             _paletteList << resource.dynamicCast<KoColorSet>();
         }
     }
     return _paletteList;
 }
 
 void KisDocument::setPaletteList(const QList<KoColorSetSP > &paletteList, bool emitSignal)
 {
     qDebug() << "SET PALETTE LIST" << paletteList.size() << "storage" << d->documentResourceStorage;
 
     QList<KoColorSetSP> oldPaletteList;
     if (d->documentResourceStorage) {
         QSharedPointer<KisResourceStorage::ResourceIterator> iter = d->documentResourceStorage->resources(ResourceType::Palettes);
         while (iter->hasNext()) {
             iter->next();
             KoResourceSP resource = iter->resource();
             if (resource && resource->valid()) {
                 oldPaletteList << resource.dynamicCast<KoColorSet>();
             }
         }
         if (oldPaletteList != paletteList) {
             KisResourceModel *resourceModel = KisResourceModelProvider::resourceModel(ResourceType::Palettes);
             Q_FOREACH(KoColorSetSP palette, oldPaletteList) {
                 resourceModel->removeResource(palette);
             }
             Q_FOREACH(KoColorSetSP palette, paletteList) {
                 qDebug()<< "loading palette into document" << palette->filename();
                 resourceModel->addResource(palette, d->documentStorageID);
             }
             if (emitSignal) {
                 emit sigPaletteListChanged(oldPaletteList, paletteList);
             }
         }
     }
 }
 
 const KisGuidesConfig& KisDocument::guidesConfig() const
 {
     return d->guidesConfig;
 }
 
 void KisDocument::setGuidesConfig(const KisGuidesConfig &data)
 {
     if (d->guidesConfig == data) return;
 
     d->guidesConfig = data;
     d->syncDecorationsWrapperLayerState();
     emit sigGuidesConfigChanged(d->guidesConfig);
 }
 
 const KisMirrorAxisConfig& KisDocument::mirrorAxisConfig() const
 {
     return d->mirrorAxisConfig;
 }
 
 void KisDocument::setMirrorAxisConfig(const KisMirrorAxisConfig &config)
 {
     if (d->mirrorAxisConfig == config) {
         return;
     }
 
     d->mirrorAxisConfig = config;
     setModified(true);
 
     emit sigMirrorAxisConfigChanged();
 }
 
 void KisDocument::resetURL() {
     setUrl(QUrl());
     setLocalFilePath(QString());
 }
 
 KoDocumentInfoDlg *KisDocument::createDocumentInfoDialog(QWidget *parent, KoDocumentInfo *docInfo) const
 {
     return new KoDocumentInfoDlg(parent, docInfo);
 }
 
 bool KisDocument::isReadWrite() const
 {
     return d->readwrite;
 }
 
 QUrl KisDocument::url() const
 {
     return d->m_url;
 }
 
 bool KisDocument::closeUrl(bool promptToSave)
 {
     if (promptToSave) {
         if ( isReadWrite() && isModified()) {
             Q_FOREACH (KisView *view, KisPart::instance()->views()) {
                 if (view && view->document() == this) {
                     if (!view->queryClose()) {
                         return false;
                     }
                 }
             }
         }
     }
     // Not modified => ok and delete temp file.
     d->mimeType = QByteArray();
 
     // It always succeeds for a read-only part,
     // but the return value exists for reimplementations
     // (e.g. pressing cancel for a modified read-write part)
     return true;
 }
 
 
 
 void KisDocument::setUrl(const QUrl &url)
 {
     d->m_url = url;
 }
 
 QString KisDocument::localFilePath() const
 {
     return d->m_file;
 }
 
 
 void KisDocument::setLocalFilePath( const QString &localFilePath )
 {
     d->m_file = localFilePath;
 }
 
 bool KisDocument::openUrlInternal(const QUrl &url)
 {
     if ( !url.isValid() ) {
         return false;
     }
 
     if (d->m_bAutoDetectedMime) {
         d->mimeType = QByteArray();
         d->m_bAutoDetectedMime = false;
     }
 
     QByteArray mimetype = d->mimeType;
 
     if ( !closeUrl() ) {
         return false;
     }
 
     d->mimeType = mimetype;
     setUrl(url);
 
     d->m_file.clear();
 
     if (d->m_url.isLocalFile()) {
         d->m_file = d->m_url.toLocalFile();
         bool ret;
         // set the mimetype only if it was not already set (for example, by the host application)
         if (d->mimeType.isEmpty()) {
             // get the mimetype of the file
             // using findByUrl() to avoid another string -> url conversion
             QString mime = KisMimeDatabase::mimeTypeForFile(d->m_url.toLocalFile());
             d->mimeType = mime.toLocal8Bit();
             d->m_bAutoDetectedMime = true;
         }
 
         setUrl(d->m_url);
         ret = openFile();
 
         if (ret) {
             emit completed();
         } else {
             emit canceled(QString());
         }
         return ret;
     }
     return false;
 }
 
 bool KisDocument::newImage(const QString& name,
                            qint32 width, qint32 height,
                            const KoColorSpace* cs,
                            const KoColor &bgColor, KisConfig::BackgroundStyle bgStyle,
                            int numberOfLayers,
                            const QString &description, const double imageResolution)
 {
     Q_ASSERT(cs);
 
     KisImageSP image;
 
     if (!cs) return false;
 
     QApplication::setOverrideCursor(Qt::BusyCursor);
 
     image = new KisImage(createUndoStore(), width, height, cs, name);
 
     Q_CHECK_PTR(image);
 
     connect(image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     image->setResolution(imageResolution, imageResolution);
 
     image->assignImageProfile(cs->profile());
     image->waitForDone();
 
     documentInfo()->setAboutInfo("title", name);
     documentInfo()->setAboutInfo("abstract", description);
 
     KisConfig cfg(false);
     cfg.defImageWidth(width);
     cfg.defImageHeight(height);
     cfg.defImageResolution(imageResolution);
-    cfg.defColorModel(image->colorSpace()->colorModelId().id());
-    cfg.setDefaultColorDepth(image->colorSpace()->colorDepthId().id());
+    if (cfg.rememberLastUsedColorSpace()) {
+        cfg.defColorModel(image->colorSpace()->colorModelId().id());
+        cfg.defColorDepth(image->colorSpace()->colorDepthId().id());
+    }
     cfg.defColorProfile(image->colorSpace()->profile()->name());
 
     bool autopin = cfg.autoPinLayersToTimeline();
 
     KisLayerSP bgLayer;
     if (bgStyle == KisConfig::RASTER_LAYER || bgStyle == KisConfig::FILL_LAYER) {
         KoColor strippedAlpha = bgColor;
         strippedAlpha.setOpacity(OPACITY_OPAQUE_U8);
 
         if (bgStyle == KisConfig::RASTER_LAYER) {
             bgLayer = new KisPaintLayer(image.data(), "Background", OPACITY_OPAQUE_U8, cs);;
             bgLayer->paintDevice()->setDefaultPixel(strippedAlpha);
             bgLayer->setPinnedToTimeline(autopin);
         } else if (bgStyle == KisConfig::FILL_LAYER) {
             KisFilterConfigurationSP filter_config = KisGeneratorRegistry::instance()->get("color")->defaultConfiguration(KisGlobalResourcesInterface::instance());
             filter_config->setProperty("color", strippedAlpha.toQColor());
             filter_config->createLocalResourcesSnapshot();
             bgLayer = new KisGeneratorLayer(image.data(), "Background Fill", filter_config, image->globalSelection());
         }
 
         bgLayer->setOpacity(bgColor.opacityU8());
 
         if (numberOfLayers > 1) {
             //Lock bg layer if others are present.
             bgLayer->setUserLocked(true);
         }
     }
     else { // KisConfig::CANVAS_COLOR (needs an unlocked starting layer).
         image->setDefaultProjectionColor(bgColor);
         bgLayer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
     }
 
     Q_CHECK_PTR(bgLayer);
     image->addNode(bgLayer.data(), image->rootLayer().data());
     bgLayer->setDirty(QRect(0, 0, width, height));
 
     setCurrentImage(image);
 
     for(int i = 1; i < numberOfLayers; ++i) {
         KisPaintLayerSP layer = new KisPaintLayer(image, image->nextLayerName(), OPACITY_OPAQUE_U8, cs);
         layer->setPinnedToTimeline(autopin);
         image->addNode(layer, image->root(), i);
         layer->setDirty(QRect(0, 0, width, height));
     }
 
     KisUsageLogger::log(QString("Created image \"%1\", %2 * %3 pixels, %4 dpi. Color model: %6 %5 (%7). Layers: %8")
                              .arg(name)
                              .arg(width).arg(height)
                              .arg(imageResolution * 72.0)
                              .arg(image->colorSpace()->colorModelId().name())
                              .arg(image->colorSpace()->colorDepthId().name())
                              .arg(image->colorSpace()->profile()->name())
                              .arg(numberOfLayers));
 
     QApplication::restoreOverrideCursor();
 
     return true;
 }
 
 bool KisDocument::isSaving() const
 {
     const bool result = d->savingMutex.tryLock();
     if (result) {
         d->savingMutex.unlock();
     }
     return !result;
 }
 
 void KisDocument::waitForSavingToComplete()
 {
     if (isSaving()) {
         KisAsyncActionFeedback f(i18nc("progress dialog message when the user closes the document that is being saved", "Waiting for saving to complete..."), 0);
         f.waitForMutex(&d->savingMutex);
     }
 }
 
 KoShapeControllerBase *KisDocument::shapeController() const
 {
     return d->shapeController;
 }
 
 KoShapeLayer* KisDocument::shapeForNode(KisNodeSP layer) const
 {
     return d->shapeController->shapeForNode(layer);
 }
 
 QList<KisPaintingAssistantSP> KisDocument::assistants() const
 {
     return d->assistants;
 }
 
 void KisDocument::setAssistants(const QList<KisPaintingAssistantSP> &value)
 {
     if (d->assistants != value) {
         d->assistants = value;
         d->syncDecorationsWrapperLayerState();
         emit sigAssistantsChanged();
     }
 }
 
 KisReferenceImagesLayerSP KisDocument::referenceImagesLayer() const
 {
     if (!d->image) return KisReferenceImagesLayerSP();
 
     KisReferenceImagesLayerSP referencesLayer =
         KisLayerUtils::findNodeByType<KisReferenceImagesLayer>(d->image->root());
 
     return referencesLayer;
 }
 
 void KisDocument::setReferenceImagesLayer(KisSharedPtr<KisReferenceImagesLayer> layer, bool updateImage)
 {
     KisReferenceImagesLayerSP currentReferenceLayer = referenceImagesLayer();
 
     if (currentReferenceLayer == layer) {
         return;
     }
 
     if (currentReferenceLayer) {
         currentReferenceLayer->disconnect(this);
     }
 
     if (updateImage) {
         if (currentReferenceLayer) {
             d->image->removeNode(currentReferenceLayer);
         }
 
         if (layer) {
             d->image->addNode(layer);
         }
     }
 
     currentReferenceLayer = layer;
 
     if (currentReferenceLayer) {
         connect(currentReferenceLayer, SIGNAL(sigUpdateCanvas(QRectF)),
                 this, SIGNAL(sigReferenceImagesChanged()));
     }
 
     emit sigReferenceImagesLayerChanged(layer);
 }
 
 void KisDocument::setPreActivatedNode(KisNodeSP activatedNode)
 {
     d->preActivatedNode = activatedNode;
 }
 
 KisNodeSP KisDocument::preActivatedNode() const
 {
     return d->preActivatedNode;
 }
 
 KisImageWSP KisDocument::image() const
 {
     return d->image;
 }
 
 KisImageSP KisDocument::savingImage() const
 {
     return d->savingImage;
 }
 
 
 void KisDocument::setCurrentImage(KisImageSP image, bool forceInitialUpdate)
 {
     if (d->image) {
         // Disconnect existing sig/slot connections
         d->image->setUndoStore(new KisDumbUndoStore());
         d->image->disconnect(this);
         d->shapeController->setImage(0);
         d->image = 0;
     }
 
     if (!image) return;
 
     if (d->documentResourceStorage){
         d->documentResourceStorage->setMetaData(KisResourceStorage::s_meta_name, image->objectName());
     }
 
     d->setImageAndInitIdleWatcher(image);
     d->image->setUndoStore(new KisDocumentUndoStore(this));
     d->shapeController->setImage(image);
     setModified(false);
     connect(d->image, SIGNAL(sigImageModified()), this, SLOT(setImageModified()), Qt::UniqueConnection);
     connect(d->image, SIGNAL(sigLayersChangedAsync()), this, SLOT(slotImageRootChanged()));
 
     if (forceInitialUpdate) {
         d->image->initialRefreshGraph();
     }
 }
 
 void KisDocument::hackPreliminarySetImage(KisImageSP image)
 {
     KIS_SAFE_ASSERT_RECOVER_RETURN(!d->image);
 
     // we set image without connecting idle-watcher, because loading
     // hasn't been finished yet
     d->image = image;
     d->shapeController->setImage(image);
 }
 
 void KisDocument::setImageModified()
 {
     // we only set as modified if undo stack is not at clean state
     setModified(!d->undoStack->isClean());
 }
 
 
 KisUndoStore* KisDocument::createUndoStore()
 {
     return new KisDocumentUndoStore(this);
 }
 
 bool KisDocument::isAutosaving() const
 {
     return d->isAutosaving;
 }
 
 QString KisDocument::exportErrorToUserMessage(KisImportExportErrorCode status, const QString &errorMessage)
 {
     return errorMessage.isEmpty() ? status.errorMessage() : errorMessage;
 }
 
 void KisDocument::setAssistantsGlobalColor(QColor color)
 {
     d->globalAssistantsColor = color;
 }
 
 QColor KisDocument::assistantsGlobalColor()
 {
     return d->globalAssistantsColor;
 }
 
 QRectF KisDocument::documentBounds() const
 {
     QRectF bounds = d->image->bounds();
 
     KisReferenceImagesLayerSP referenceImagesLayer = this->referenceImagesLayer();
 
     if (referenceImagesLayer) {
         bounds |= referenceImagesLayer->boundingImageRect();
     }
 
     return bounds;
 }
diff --git a/libs/ui/KisMainWindow.cpp b/libs/ui/KisMainWindow.cpp
index 5f610cf094..6d23dff950 100644
--- a/libs/ui/KisMainWindow.cpp
+++ b/libs/ui/KisMainWindow.cpp
@@ -1,2722 +1,2722 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (C) 2000-2006 David Faure <faure@kde.org>
    Copyright (C) 2007, 2009 Thomas zander <zander@kde.org>
    Copyright (C) 2010 Benjamin Port <port.benjamin@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
 */
 
 #include "KisMainWindow.h"
 
 #include <KoConfig.h>
 
 // qt includes
 #include <QApplication>
 #include <QByteArray>
 #include <QCloseEvent>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QDesktopWidget>
 #include <QDialog>
 #include <QDockWidget>
 #include <QIcon>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QMdiArea>
 #include <QMdiSubWindow>
 #include <QMutex>
 #include <QMutexLocker>
 #include <QPointer>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPrintPreviewDialog>
 #include <QToolButton>
 #include <KisSignalMapper.h>
 #include <QTabBar>
 #include <QMoveEvent>
 #include <QUrl>
 #include <QMessageBox>
 #include <QStatusBar>
 #include <QStyleFactory>
 #include <QMenu>
 #include <QMenuBar>
 #include <KisMimeDatabase.h>
 #include <QMimeData>
 #include <QStackedWidget>
 #include <QProxyStyle>
 #include <QScreen>
 #include <QAction>
 #include <QWindow>
 #include <QScrollArea>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kis_debug.h>
 #include <kedittoolbar.h>
 #include <khelpmenu.h>
 #include <klocalizedstring.h>
 #include <kaboutdata.h>
 #include <kis_workspace_resource.h>
 #include <input/kis_input_manager.h>
 #include "kis_selection_manager.h"
 #include "kis_icon_utils.h"
 #include <krecentfilesaction.h>
 #include <ktoggleaction.h>
 #include <ktoolbar.h>
 #include <kmainwindow.h>
 #include <kxmlguiwindow.h>
 #include <kxmlguifactory.h>
 #include <kxmlguiclient.h>
 #include <kguiitem.h>
 #include <kwindowconfig.h>
 #include <kformat.h>
 
 #include <KoResourcePaths.h>
 #include <KoToolFactoryBase.h>
 #include <KoToolRegistry.h>
 #include "KoDockFactoryBase.h"
 #include "KoDocumentInfoDlg.h"
 #include "KoDocumentInfo.h"
 #include "KoFileDialog.h"
 #include <kis_icon.h>
 #include <KoToolManager.h>
 #include <KoZoomController.h>
 #include "KoToolDocker.h"
 #include "KoToolBoxDocker_p.h"
 #include <KoToolBoxFactory.h>
 #include <KoDockRegistry.h>
 #include <KoPluginLoader.h>
 #include <KoColorSpaceEngine.h>
 #include <KoUpdater.h>
 #include <KisResourceModel.h>
 #include <KisResourceModelProvider.h>
 #include <KisResourceLoaderRegistry.h>
 #include <KisResourceIterator.h>
 #include <KisResourceTypes.h>
 #include <KisResourceCacheDb.h>
 
 #ifdef Q_OS_ANDROID
 #include <KisAndroidFileManager.h>
 #endif
 
 #include <KisUsageLogger.h>
 #include <brushengine/kis_paintop_settings.h>
 #include "dialogs/kis_about_application.h"
 #include "dialogs/kis_delayed_save_dialog.h"
 #include "dialogs/kis_dlg_preferences.h"
 #include "kis_action_manager.h"
 #include "KisApplication.h"
 #include "kis_canvas2.h"
 #include "kis_canvas_controller.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_clipboard.h"
 #include "kis_config.h"
 #include "kis_config_notifier.h"
 #include "kis_custom_image_widget.h"
 #include <KisDocument.h>
 #include "kis_group_layer.h"
 #include "kis_image_from_clipboard_widget.h"
 #include "kis_image.h"
 #include <KisImportExportFilter.h>
 #include "KisImportExportManager.h"
 #include "kis_mainwindow_observer.h"
 #include "kis_memory_statistics_server.h"
 #include "kis_node.h"
 #include "KisOpenPane.h"
 #include "kis_paintop_box.h"
 #include "KisPart.h"
 #include "KisResourceServerProvider.h"
 #include "kis_signal_compressor_with_param.h"
 #include "kis_statusbar.h"
 #include "KisView.h"
 #include "KisViewManager.h"
 #include "thememanager.h"
 #include "kis_animation_importer.h"
 #include "dialogs/kis_dlg_import_image_sequence.h"
 #include <KisImageConfigNotifier.h>
 #include "KisWindowLayoutManager.h"
 #include <KisUndoActionsUpdateManager.h>
 #include "KisWelcomePageWidget.h"
 #include <KritaVersionWrapper.h>
 #include <kritaversion.h>
 #include "KisCanvasWindow.h"
 #include "kis_action.h"
 
 #include <mutex>
 
 class ToolDockerFactory : public KoDockFactoryBase
 {
 public:
     ToolDockerFactory() : KoDockFactoryBase() { }
 
     QString id() const override {
         return "sharedtooldocker";
     }
 
     QDockWidget* createDockWidget() override {
         KoToolDocker* dockWidget = new KoToolDocker();
         return dockWidget;
     }
 
     DockPosition defaultDockPosition() const override {
         return DockRight;
     }
 };
 
 class Q_DECL_HIDDEN KisMainWindow::Private
 {
 public:
     Private(KisMainWindow *parent, QUuid id)
         : q(parent)
         , id(id)
         , styleMenu(new KActionMenu(i18nc("@action:inmenu", "Styles"), parent))
         , dockWidgetMenu(new KActionMenu(i18nc("@action:inmenu", "&Dockers"), parent))
         , windowMenu(new KActionMenu(i18nc("@action:inmenu", "&Window"), parent))
         , documentMenu(new KActionMenu(i18nc("@action:inmenu", "New &View"), parent))
         , workspaceMenu(new KActionMenu(i18nc("@action:inmenu", "Wor&kspace"), parent))
         , welcomePage(new KisWelcomePageWidget(parent))
         , widgetStack(new QStackedWidget(parent))
         , mdiArea(new QMdiArea(parent))
         , windowMapper(new KisSignalMapper(parent))
         , documentMapper(new KisSignalMapper(parent))
     #ifdef Q_OS_ANDROID
         , fileManager(new KisAndroidFileManager(parent))
     #endif
 
     {
         if (id.isNull()) this->id = QUuid::createUuid();
 
         welcomeScroller = new QScrollArea();
         welcomeScroller->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         welcomeScroller->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
         welcomeScroller->setWidget(welcomePage);
         welcomeScroller->setWidgetResizable(true);
 
         widgetStack->addWidget(welcomeScroller);
         widgetStack->addWidget(mdiArea);
         mdiArea->setTabsMovable(true);
         mdiArea->setActivationOrder(QMdiArea::ActivationHistoryOrder);
     }
 
     ~Private() {
         qDeleteAll(toolbarList);
     }
 
     KisMainWindow *q {0};
     QUuid id;
 
     KisViewManager *viewManager {0};
 
     QPointer<KisView> activeView;
 
     QList<QAction *> toolbarList;
 
     bool firstTime {true};
     bool windowSizeDirty {false};
     bool readOnly {false};
 
     KisAction *showDocumentInfo {0};
     KisAction *saveAction {0};
     KisAction *saveActionAs {0};
     KisAction *importAnimation {0};
     KisAction *closeAll {0};
     KisAction *importFile {0};
     KisAction *exportFile {0};
     KisAction *undo {0};
     KisAction *redo {0};
     KisAction *newWindow {0};
     KisAction *close {0};
     KisAction *mdiCascade {0};
     KisAction *mdiTile {0};
     KisAction *mdiNextWindow {0};
     KisAction *mdiPreviousWindow {0};
     KisAction *toggleDockers {0};
     KisAction *resetConfigurations {0};
     KisAction *toggleDockerTitleBars {0};
     KisAction *toggleDetachCanvas {0};
     KisAction *fullScreenMode {0};
     KisAction *showSessionManager {0};
 
     KisAction *expandingSpacers[2];
 
     KActionMenu *styleMenu;
     QActionGroup* styleActions;
     QMap<QString, QAction*> actionMap;
 
     KActionMenu *dockWidgetMenu;
     KActionMenu *windowMenu;
     KActionMenu *documentMenu;
     KActionMenu *workspaceMenu;
 
     KHelpMenu *helpMenu  {0};
 
     KRecentFilesAction *recentFiles {0};
     KisResourceModel *workspacemodel {0};
 
     QScopedPointer<KisUndoActionsUpdateManager> undoActionsUpdateManager;
 
     QString lastExportLocation;
 
     QMap<QString, QDockWidget *> dockWidgetsMap;
     QByteArray dockerStateBeforeHiding;
     KoToolDocker *toolOptionsDocker {0};
 
     QCloseEvent *deferredClosingEvent {0};
 
     Digikam::ThemeManager *themeManager {0};
 
     QScrollArea *welcomeScroller {0};
     KisWelcomePageWidget *welcomePage {0};
 
 
     QStackedWidget *widgetStack {0};
 
     QMdiArea *mdiArea;
     QMdiSubWindow *activeSubWindow  {0};
     KisSignalMapper *windowMapper;
     KisSignalMapper *documentMapper;
     KisCanvasWindow *canvasWindow {0};
 
     QByteArray lastExportedFormat;
     QScopedPointer<KisSignalCompressorWithParam<int> > tabSwitchCompressor;
     QMutex savingEntryMutex;
 
     KConfigGroup windowStateConfig;
 
     QUuid workspaceBorrowedBy;
     KisSignalAutoConnectionsStore screenConnectionsStore;
 
 #ifdef Q_OS_ANDROID
     KisAndroidFileManager *fileManager;
 #endif
 
     KisActionManager * actionManager() {
         return viewManager->actionManager();
     }
 
     QTabBar* findTabBarHACK() {
         QObjectList objects = mdiArea->children();
         Q_FOREACH (QObject *object, objects) {
             QTabBar *bar = qobject_cast<QTabBar*>(object);
             if (bar) {
                 return bar;
             }
         }
         return 0;
     }
 };
 
 KisMainWindow::KisMainWindow(QUuid uuid)
     : KXmlGuiWindow()
     , d(new Private(this, uuid))
 {
     d->workspacemodel = KisResourceModelProvider::resourceModel(ResourceType::Workspaces);
     connect(d->workspacemodel, SIGNAL(afterResourcesLayoutReset()), this, SLOT(updateWindowMenu()));
 
     d->viewManager = new KisViewManager(this, actionCollection());
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager = new Digikam::ThemeManager(group.readEntry("Theme", "Krita dark"), this);
 
     d->windowStateConfig = KSharedConfig::openConfig()->group("MainWindow");
 
     setStandardToolBarMenuEnabled(true);
     setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
     setDockNestingEnabled(true);
 
     qApp->setStartDragDistance(25);     // 25 px is a distance that works well for Tablet and Mouse events
 
 #ifdef Q_OS_MACOS
     setUnifiedTitleAndToolBarOnMac(true);
 #endif
 
     connect(this, SIGNAL(restoringDone()), this, SLOT(forceDockTabFonts()));
     connect(this, SIGNAL(themeChanged()), d->viewManager, SLOT(updateIcons()));
     connect(KisPart::instance(), SIGNAL(documentClosed(QString)), SLOT(updateWindowMenu()));
     connect(KisPart::instance(), SIGNAL(documentOpened(QString)), SLOT(updateWindowMenu()));
     connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), this, SLOT(configChanged()));
 
     actionCollection()->addAssociatedWidget(this);
     KoPluginLoader::instance()->load("Krita/ViewPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), d->viewManager, false);
 
     // Load the per-application plugins (Right now, only Python) We do this only once, when the first mainwindow is being created.
     KoPluginLoader::instance()->load("Krita/ApplicationPlugin", "Type == 'Service' and ([X-Krita-Version] == 28)", KoPluginLoader::PluginsConfig(), qApp, true);
 
     KoToolBoxFactory toolBoxFactory;
     QDockWidget *toolbox = createDockWidget(&toolBoxFactory);
     toolbox->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable | QDockWidget::DockWidgetClosable);
 
     KisConfig cfg(true);
     if (cfg.toolOptionsInDocker()) {
         ToolDockerFactory toolDockerFactory;
         d->toolOptionsDocker = qobject_cast<KoToolDocker*>(createDockWidget(&toolDockerFactory));
         d->toolOptionsDocker->toggleViewAction()->setEnabled(true);
     }
 
     QMap<QString, QAction*> dockwidgetActions;
     dockwidgetActions[toolbox->toggleViewAction()->text()] = toolbox->toggleViewAction();
     Q_FOREACH (const QString & docker, KoDockRegistry::instance()->keys()) {
         KoDockFactoryBase *factory = KoDockRegistry::instance()->value(docker);
         QDockWidget *dw = createDockWidget(factory);
         dockwidgetActions[dw->toggleViewAction()->text()] = dw->toggleViewAction();
     }
 
     if (d->toolOptionsDocker) {
         dockwidgetActions[d->toolOptionsDocker->toggleViewAction()->text()] = d->toolOptionsDocker->toggleViewAction();
     }
     connect(KoToolManager::instance(), SIGNAL(toolOptionWidgetsChanged(KoCanvasController*,QList<QPointer<QWidget> >)), this, SLOT(newOptionWidgets(KoCanvasController*,QList<QPointer<QWidget> >)));
 
     Q_FOREACH (QString title, dockwidgetActions.keys()) {
         d->dockWidgetMenu->addAction(dockwidgetActions[title]);
     }
 
 
     // Style menu actions
     d->styleActions = new QActionGroup(this);
     QAction * action;
     Q_FOREACH (QString styleName, QStyleFactory::keys()) {
         action = new QAction(styleName, d->styleActions);
         action->setCheckable(true);
         d->actionMap.insert(styleName, action);
         d->styleMenu->addAction(d->actionMap.value(styleName));
     }
 
 
     // select the config value, or the current style if that does not exist
     QString styleFromConfig = cfg.widgetStyle().toLower();
     QString styleToSelect = styleFromConfig == "" ? style()->objectName().toLower() : styleFromConfig;
 
     Q_FOREACH (auto key, d->actionMap.keys()) {
         if(key.toLower() == styleToSelect) { // does the key match selection
             d->actionMap.value(key)->setChecked(true);
         }
     }
 
     connect(d->styleActions, SIGNAL(triggered(QAction*)),
             this, SLOT(slotUpdateWidgetStyle()));
 
 
 
 
     Q_FOREACH (QDockWidget *wdg, dockWidgets()) {
         if ((wdg->features() & QDockWidget::DockWidgetClosable) == 0) {
             wdg->setVisible(true);
         }
     }
 
     Q_FOREACH (KoCanvasObserverBase* observer, canvasObservers()) {
         observer->setObservedCanvas(0);
         KisMainwindowObserver* mainwindowObserver = dynamic_cast<KisMainwindowObserver*>(observer);
         if (mainwindowObserver) {
             mainwindowObserver->setViewManager(d->viewManager);
         }
     }
 
     // Load all the actions from the tool plugins
     Q_FOREACH(KoToolFactoryBase *toolFactory, KoToolRegistry::instance()->values()) {
         toolFactory->createActions(actionCollection());
     }
 
     d->mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     d->mdiArea->setTabPosition(QTabWidget::North);
     d->mdiArea->setTabsClosable(true);
 
     // Tab close button override
     // Windows just has a black X, and Ubuntu has a dark x that is hard to read
     // just switch this icon out for all OSs so it is easier to see
     d->mdiArea->setStyleSheet("QTabBar::close-button { image: url(:/pics/broken-preset.png) }");
 
     setCentralWidget(d->widgetStack);
     d->widgetStack->setCurrentIndex(0);
 
     connect(d->mdiArea, SIGNAL(subWindowActivated(QMdiSubWindow*)), this, SLOT(subWindowActivated()));
     connect(d->windowMapper, SIGNAL(mapped(QWidget*)), this, SLOT(setActiveSubWindow(QWidget*)));
     connect(d->documentMapper, SIGNAL(mapped(QObject*)), this, SLOT(newView(QObject*)));
 
     d->canvasWindow = new KisCanvasWindow(this);
     actionCollection()->addAssociatedWidget(d->canvasWindow);
 
     createActions();
 
     // the welcome screen needs to grab actions...so make sure this line goes after the createAction() so they exist
     d->welcomePage->setMainWindow(this);
 
     setAutoSaveSettings(d->windowStateConfig, false);
 
     subWindowActivated();
     updateWindowMenu();
 
     if (isHelpMenuEnabled() && !d->helpMenu) {
         // workaround for KHelpMenu (or rather KAboutData::applicationData()) internally
         // not using the Q*Application metadata ATM, which results e.g. in the bugreport wizard
         // not having the app version preset
         // fixed hopefully in KF5 5.22.0, patch pending
         QGuiApplication *app = qApp;
         KAboutData aboutData(app->applicationName(), app->applicationDisplayName(), app->applicationVersion());
         aboutData.setOrganizationDomain(app->organizationDomain().toUtf8());
         d->helpMenu = new KHelpMenu(this, aboutData, false);
         // workaround-less version:
         // d->helpMenu = new KHelpMenu(this, QString()/*unused*/, false);
 
         // The difference between using KActionCollection->addAction() is that
         // these actions do not get tied to the MainWindow.  What does this all do?
         KActionCollection *actions = d->viewManager->actionCollection();
         QAction *helpContentsAction = d->helpMenu->action(KHelpMenu::menuHelpContents);
         QAction *whatsThisAction = d->helpMenu->action(KHelpMenu::menuWhatsThis);
         QAction *reportBugAction = d->helpMenu->action(KHelpMenu::menuReportBug);
         QAction *switchLanguageAction = d->helpMenu->action(KHelpMenu::menuSwitchLanguage);
         QAction *aboutAppAction = d->helpMenu->action(KHelpMenu::menuAboutApp);
         QAction *aboutKdeAction = d->helpMenu->action(KHelpMenu::menuAboutKDE);
 
         if (helpContentsAction) {
             actions->addAction(helpContentsAction->objectName(), helpContentsAction);
         }
         if (whatsThisAction) {
             actions->addAction(whatsThisAction->objectName(), whatsThisAction);
         }
         if (reportBugAction) {
             actions->addAction(reportBugAction->objectName(), reportBugAction);
         }
         if (switchLanguageAction) {
             actions->addAction(switchLanguageAction->objectName(), switchLanguageAction);
         }
         if (aboutAppAction) {
             actions->addAction(aboutAppAction->objectName(), aboutAppAction);
         }
         if (aboutKdeAction) {
             actions->addAction(aboutKdeAction->objectName(), aboutKdeAction);
         }
 
         connect(d->helpMenu, SIGNAL(showAboutApplication()), SLOT(showAboutApplication()));
     }
 
     // KDE' libs 4''s help contents action is broken outside kde, for some reason... We can handle it just as easily ourselves
     QAction *helpAction = actionCollection()->action("help_contents");
     helpAction->disconnect();
     connect(helpAction, SIGNAL(triggered()), this, SLOT(showManual()));
 
 #if 0
     //check for colliding shortcuts
     QSet<QKeySequence> existingShortcuts;
     Q_FOREACH (QAction* action, actionCollection()->actions()) {
         if(action->shortcut() == QKeySequence(0)) {
             continue;
         }
         dbgKrita << "shortcut " << action->text() << " " << action->shortcut();
         Q_ASSERT(!existingShortcuts.contains(action->shortcut()));
         existingShortcuts.insert(action->shortcut());
     }
 #endif
 
     configChanged();
 
     // Make sure the python plugins create their actions in time
     KisPart::instance()->notifyMainWindowIsBeingCreated(this);
 
     // If we have customized the toolbars, load that first
     setLocalXMLFile(KoResourcePaths::locateLocal("data", "krita5.xmlgui"));
     setXMLFile(":/kxmlgui5/krita5.xmlgui");
 
     guiFactory()->addClient(this);
     connect(guiFactory(), SIGNAL(makingChanges(bool)), SLOT(slotXmlGuiMakingChanges(bool)));
 
     // Create and plug toolbar list for Settings menu
     QList<QAction *> toolbarList;
     Q_FOREACH (QWidget* it, guiFactory()->containers("ToolBar")) {
         KToolBar * toolBar = ::qobject_cast<KToolBar *>(it);
         if (toolBar) {
             toolBar->setMovable(KisConfig(true).readEntry<bool>("LockAllDockerPanels", false));
             if (toolBar->objectName() == "BrushesAndStuff") {
                 toolBar->setEnabled(false);
             }
 
             KToggleAction* act = new KToggleAction(i18n("Show %1 Toolbar", toolBar->windowTitle()), this);
             actionCollection()->addAction(toolBar->objectName().toUtf8(), act);
             act->setCheckedState(KGuiItem(i18n("Hide %1 Toolbar", toolBar->windowTitle())));
             connect(act, SIGNAL(toggled(bool)), this, SLOT(slotToolbarToggled(bool)));
             act->setChecked(!toolBar->isHidden());
             toolbarList.append(act);
         } else {
             warnUI << "Toolbar list contains a " << it->metaObject()->className() << " which is not a toolbar!";
         }
     }
 
     KToolBar::setToolBarsLocked(KisConfig(true).readEntry<bool>("LockAllDockerPanels", false));
     plugActionList("toolbarlist", toolbarList);
     d->toolbarList = toolbarList;
 
     applyToolBarLayout();
 
     d->viewManager->updateGUI();
     d->viewManager->updateIcons();
 
     QTimer::singleShot(1000, this, SLOT(checkSanity()));
 
     {
         using namespace std::placeholders; // For _1 placeholder
         std::function<void (int)> callback(
                     std::bind(&KisMainWindow::switchTab, this, _1));
 
         d->tabSwitchCompressor.reset(
                     new KisSignalCompressorWithParam<int>(500, callback, KisSignalCompressor::FIRST_INACTIVE));
     }
 
 
     if (cfg.readEntry("CanvasOnlyActive", false)) {
         QString currentWorkspace = cfg.readEntry<QString>("CurrentWorkspace", "Default");
         KoResourceServer<KisWorkspaceResource> * rserver = KisResourceServerProvider::instance()->workspaceServer();
         KisWorkspaceResourceSP workspace = rserver->resourceByName(currentWorkspace);
         if (workspace) {
             restoreWorkspace(workspace->resourceId());
         }
         cfg.writeEntry("CanvasOnlyActive", false);
         menuBar()->setVisible(true);
     }
 
     this->winId(); // Ensures the native window has been created.
     QWindow *window = this->windowHandle();
     connect(window, SIGNAL(screenChanged(QScreen *)), this, SLOT(windowScreenChanged(QScreen *)));
 
 }
 
 KisMainWindow::~KisMainWindow()
 {
     //    Q_FOREACH (QAction *ac, actionCollection()->actions()) {
     //        QAction *action = qobject_cast<QAction*>(ac);
     //        if (action) {
     //        qDebug() << "<Action"
     //                 << "\n\tname=" << action->objectName()
     //                 << "\n\ticon=" << action->icon().name()
     //                 << "\n\ttext="  << action->text().replace("&", "&amp;")
     //                 << "\n\twhatsThis="  << action->whatsThis()
     //                 << "\n\ttoolTip="  << action->toolTip().replace("<html>", "").replace("</html>", "")
     //                 << "\n\ticonText="  << action->iconText().replace("&", "&amp;")
     //                 << "\n\tshortcut="  << action->shortcut().toString()
     //                 << "\n\tisCheckable="  << QString((action->isChecked() ? "true" : "false"))
     //                 << "\n\tstatusTip=" << action->statusTip()
     //                 << "\n/>\n"   ;
     //        }
     //        else {
     //            dbgKrita << "Got a non-qaction:" << ac->objectName();
     //        }
     //    }
 
     // The doc and view might still exist (this is the case when closing the window)
     KisPart::instance()->removeMainWindow(this);
 
     delete d->viewManager;
     delete d;
 
 }
 
 QUuid KisMainWindow::id() const {
     return d->id;
 }
 
 void KisMainWindow::addView(KisView *view, QMdiSubWindow *subWindow)
 {
     if (d->activeView == view && !subWindow) return;
 
     if (d->activeView) {
         d->activeView->disconnect(this);
     }
 
     // register the newly created view in the input manager
     viewManager()->inputManager()->addTrackedCanvas(view->canvasBase());
 
     showView(view, subWindow);
     updateCaption();
     emit restoringDone();
 
     if (d->activeView) {
         connect(d->activeView, SIGNAL(titleModified(QString,bool)), SLOT(slotDocumentTitleModified()));
         connect(d->viewManager->statusBar(), SIGNAL(memoryStatusUpdated()), this, SLOT(updateCaption()));
     }
 }
 
 void KisMainWindow::notifyChildViewDestroyed(KisView *view)
 {
     /**
      * If we are the last view of the window, Qt will not activate another tab
      * before destroying tab/window. In this case we should clear all the dangling
      * pointers manually by setting the current view to null
      */
     viewManager()->inputManager()->removeTrackedCanvas(view->canvasBase());
     if (view->canvasBase() == viewManager()->canvasBase()) {
         viewManager()->setCurrentView(0);
     }
 }
 
 
 void KisMainWindow::showView(KisView *imageView, QMdiSubWindow *subwin)
 {
     if (imageView && activeView() != imageView) {
         // XXX: find a better way to initialize this!
         imageView->setViewManager(d->viewManager);
 
         imageView->canvasBase()->setFavoriteResourceManager(d->viewManager->paintOpBox()->favoriteResourcesManager());
         imageView->slotLoadingFinished();
 
         if (!subwin) {
             subwin = d->mdiArea->addSubWindow(imageView);
         } else {
             subwin->setWidget(imageView);
         }
         imageView->setSubWindow(subwin);
         subwin->setAttribute(Qt::WA_DeleteOnClose, true);
         connect(subwin, SIGNAL(destroyed()), SLOT(updateWindowMenu()));
 
         KisConfig cfg(true);
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setWindowIcon(qApp->windowIcon());
 
 #ifdef Q_OS_MACOS
         connect(subwin, SIGNAL(destroyed()), SLOT(updateSubwindowFlags()));
         updateSubwindowFlags();
 #endif
 
         if (d->mdiArea->subWindowList().size() == 1) {
             imageView->showMaximized();
         }
         else {
             imageView->show();
         }
 
         /**
          * Hack alert!
          *
          * Here we explicitly request KoToolManager to emit all the tool
          * activation signals, to reinitialize the tool options docker.
          *
          * That is needed due to a design flaw we have in the
          * initialization procedure.  The tool in the KoToolManager is
          * initialized in KisView::setViewManager() calls, which
          * happens early enough. During this call the tool manager
          * requests KoCanvasControllerWidget to emit the signal to
          * update the widgets in the tool docker. *But* at that moment
          * of time the view is not yet connected to the main window,
          * because it happens in KisViewManager::setCurrentView a bit
          * later. This fact makes the widgets updating signals be lost
          * and never reach the tool docker.
          *
          * So here we just explicitly call the tool activation stub.
          */
 
         KoToolManager::instance()->initializeCurrentToolForCanvas();
 
         // No, no, no: do not try to call this _before_ the show() has
         // been called on the view; only when that has happened is the
         // opengl context active, and very bad things happen if we tell
         // the dockers to update themselves with a view if the opengl
         // context is not active.
         setActiveView(imageView);
 
         updateWindowMenu();
         updateCaption();
     }
 }
 
 void KisMainWindow::slotPreferences()
 {
     QScopedPointer<KisDlgPreferences> dlgPreferences(new KisDlgPreferences(this));
 
     if (dlgPreferences->editPreferences()) {
         KisConfigNotifier::instance()->notifyConfigChanged();
         KisConfigNotifier::instance()->notifyPixelGridModeChanged();
         KisImageConfigNotifier::instance()->notifyConfigChanged();
 
         // XXX: should this be changed for the views in other windows as well?
         Q_FOREACH (QPointer<KisView> koview, KisPart::instance()->views()) {
             KisViewManager *view = qobject_cast<KisViewManager*>(koview);
             if (view) {
                 // Update the settings for all nodes -- they don't query
                 // KisConfig directly because they need the settings during
                 // compositing, and they don't connect to the config notifier
                 // because nodes are not QObjects (because only one base class
                 // can be a QObject).
                 KisNode* node = dynamic_cast<KisNode*>(view->image()->rootLayer().data());
                 node->updateSettings();
             }
 
         }
         updateWindowMenu();
 
         d->viewManager->showHideScrollbars();
     }
 }
 
 void KisMainWindow::slotThemeChanged()
 {
     // save theme changes instantly
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     group.writeEntry("Theme", d->themeManager->currentThemeName());
 
     // reload action icons!
     Q_FOREACH (QAction *action, actionCollection()->actions()) {
         KisIconUtils::updateIcon(action);
     }
     if (d->mdiArea) {
         d->mdiArea->setPalette(qApp->palette());
         for (int i=0; i<d->mdiArea->subWindowList().size(); i++) {
             QMdiSubWindow *window = d->mdiArea->subWindowList().at(i);
             if (window) {
                 window->setPalette(qApp->palette());
                 KisView *view = qobject_cast<KisView*>(window->widget());
                 if (view) {
                     view->slotThemeChanged(qApp->palette());
                 }
             }
         }
     }
 
     emit themeChanged();
 }
 
 bool KisMainWindow::canvasDetached() const
 {
     return centralWidget() != d->widgetStack;
 }
 
 void KisMainWindow::setCanvasDetached(bool detach)
 {
     if (detach == canvasDetached()) return;
 
     QWidget *outgoingWidget = centralWidget() ? takeCentralWidget() : nullptr;
     QWidget *incomingWidget = d->canvasWindow->swapMainWidget(outgoingWidget);
 
     if (incomingWidget) {
         setCentralWidget(incomingWidget);
     }
 
     if (detach) {
         d->canvasWindow->show();
     } else {
         d->canvasWindow->hide();
     }
 }
 
 void KisMainWindow::slotFileSelected(QString path)
 {
     QString url = path;
     if (!url.isEmpty()) {
         bool res = openDocument(QUrl::fromLocalFile(url), Import);
         if (!res) {
             warnKrita << "Loading" << url << "failed";
         }
     }
 }
 
 void KisMainWindow::slotEmptyFilePath()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The chosen file's location could not be found. Does it exist?"));
 }
 
 QWidget * KisMainWindow::canvasWindow() const
 {
     return d->canvasWindow;
 }
 
 void KisMainWindow::setReadWrite(bool readwrite)
 {
     d->saveAction->setEnabled(readwrite);
     d->importFile->setEnabled(readwrite);
     d->readOnly = !readwrite;
     updateCaption();
 }
 
 void KisMainWindow::addRecentURL(const QUrl &url, const QUrl &oldUrl)
 {
     // Add entry to recent documents list
     // (call coming from KisDocument because it must work with cmd line, template dlg, file/open, etc.)
     if (!url.isEmpty()) {
         bool ok = true;
         if (url.isLocalFile()) {
             QString path = url.adjusted(QUrl::StripTrailingSlash).toLocalFile();
             const QStringList tmpDirs = KoResourcePaths::resourceDirs("tmp");
             for (QStringList::ConstIterator it = tmpDirs.begin() ; ok && it != tmpDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the tmp resource
                 }
             }
 
             const QStringList templateDirs = KoResourcePaths::findDirs("templates");
             for (QStringList::ConstIterator it = templateDirs.begin() ; ok && it != templateDirs.end() ; ++it) {
                 if (path.contains(*it)) {
                     ok = false; // it's in the templates directory.
                     break;
                 }
             }
         }
         if (ok) {
             if (!oldUrl.isEmpty()) {
                 d->recentFiles->removeUrl(oldUrl);
             }
             d->recentFiles->addUrl(url);
         }
         saveRecentFiles();
 
     }
 }
 
 void KisMainWindow::saveRecentFiles()
 {
     // Save list of recent files
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 
     // Tell all windows to reload their list, after saving
     // Doesn't work multi-process, but it's a start
     Q_FOREACH (KisMainWindow *mw, KisPart::instance()->mainWindows()) {
         if (mw != this) {
             mw->reloadRecentFileList();
         }
     }
 }
 
 QList<QUrl> KisMainWindow::recentFilesUrls()
 {
     return d->recentFiles->urls();
 }
 
 void KisMainWindow::clearRecentFiles()
 {
     d->recentFiles->clear();
     d->welcomePage->populateRecentDocuments();
 }
 
 void KisMainWindow::removeRecentUrl(const QUrl &url)
 {
     d->recentFiles->removeUrl(url);
     KSharedConfigPtr config =  KSharedConfig::openConfig();
     d->recentFiles->saveEntries(config->group("RecentFiles"));
     config->sync();
 }
 
 void KisMainWindow::reloadRecentFileList()
 {
     d->recentFiles->loadEntries(KSharedConfig::openConfig()->group("RecentFiles"));
 }
 
 void KisMainWindow::updateCaption()
 {
     if (!d->mdiArea->activeSubWindow()) {
         updateCaption(QString(), false);
     }
     else if (d->activeView && d->activeView->document() && d->activeView->image()){
         KisDocument *doc = d->activeView->document();
 
         QString caption(doc->caption());
 
         caption = "RESOURCES REWRITE GOING ON " + caption;
 
 
         if (d->readOnly) {
             caption += " [" + i18n("Write Protected") + "] ";
         }
 
         if (doc->isRecovered()) {
             caption += " [" + i18n("Recovered") + "] ";
         }
 
         // show the file size for the document
         KisMemoryStatisticsServer::Statistics m_fileSizeStats = KisMemoryStatisticsServer::instance()->fetchMemoryStatistics(d->activeView ? d->activeView->image() : 0);
 
         if (m_fileSizeStats.imageSize) {
             caption += QString(" (").append( KFormat().formatByteSize(m_fileSizeStats.imageSize)).append( ")");
         }
 
         updateCaption(caption, doc->isModified());
 
         if (!doc->url().fileName().isEmpty()) {
             d->saveAction->setToolTip(i18n("Save as %1", doc->url().fileName()));
         }
         else {
             d->saveAction->setToolTip(i18n("Save"));
         }
 
 
     }
 
 }
 
 void KisMainWindow::updateCaption(const QString &caption, bool modified)
 {
     QString versionString = KritaVersionWrapper::versionString(true);
 
     QString title = caption;
     if (!title.contains(QStringLiteral("[*]"))) { // append the placeholder so that the modified mechanism works
         title.append(QStringLiteral(" [*]"));
     }
 
     if (d->mdiArea->activeSubWindow()) {
 #if defined(KRITA_ALPHA) || defined (KRITA_BETA) || defined (KRITA_RC)
         d->mdiArea->activeSubWindow()->setWindowTitle(QString("%1: %2").arg(versionString).arg(title));
 #else
         d->mdiArea->activeSubWindow()->setWindowTitle(title);
 #endif
         d->mdiArea->activeSubWindow()->setWindowModified(modified);
     }
     else {
 #if defined(KRITA_ALPHA) || defined (KRITA_BETA) || defined (KRITA_RC)
     setWindowTitle(QString("%1: %2").arg(versionString).arg(title));
 #else
     setWindowTitle(title);
 #endif
     }
     setWindowModified(modified);
 
 
 }
 
 
 KisView *KisMainWindow::activeView() const
 {
     if (d->activeView) {
         return d->activeView;
     }
     return 0;
 }
 
 bool KisMainWindow::openDocument(const QUrl &url, OpenFlags flags)
 {
     if (!QFile(url.toLocalFile()).exists()) {
         if (!(flags & BatchMode)) {
             QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("The file %1 does not exist.", url.url()));
         }
         d->recentFiles->removeUrl(url); //remove the file from the recent-opened-file-list
         saveRecentFiles();
         return false;
     }
     return openDocumentInternal(url, flags);
 }
 
 bool KisMainWindow::openDocumentInternal(const QUrl &url, OpenFlags flags)
 {
     if (!url.isLocalFile()) {
         qWarning() << "KisMainWindow::openDocumentInternal. Not a local file:" << url;
         return false;
     }
 
     KisDocument *newdoc = KisPart::instance()->createDocument();
 
     if (flags & BatchMode) {
         newdoc->setFileBatchMode(true);
     }
 
     d->firstTime = true;
     connect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     connect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
     KisDocument::OpenFlags openFlags = KisDocument::None;
     // XXX: Why this duplication of of OpenFlags...
     if (flags & RecoveryFile) {
         openFlags |= KisDocument::RecoveryFile;
     }
 
     bool openRet = !(flags & Import) ? newdoc->openUrl(url, openFlags) : newdoc->importDocument(url);
 
     if (!openRet) {
         delete newdoc;
         return false;
     }
 
     KisPart::instance()->addDocument(newdoc);
 
     if (!QFileInfo(url.toLocalFile()).isWritable()) {
         setReadWrite(false);
     }
 
     // Try to determine whether this was an unnamed autosave
     if (flags & RecoveryFile &&
             (   url.toLocalFile().startsWith(QDir::tempPath())
                 || url.toLocalFile().startsWith(QDir::homePath())
                 ) &&
             (      QFileInfo(url.toLocalFile()).fileName().startsWith(".krita")
                    || QFileInfo(url.toLocalFile()).fileName().startsWith("krita")
                    )
             )
     {
         QString path = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
         if (!QFileInfo(path).exists()) {
             path = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
         }
         newdoc->setUrl(QUrl::fromLocalFile( path + "/" + newdoc->objectName() + ".kra"));
     }
 
     return true;
 }
 
 void KisMainWindow::showDocument(KisDocument *document) {
     Q_FOREACH(QMdiSubWindow *subwindow, d->mdiArea->subWindowList()) {
         KisView *view = qobject_cast<KisView*>(subwindow->widget());
         KIS_SAFE_ASSERT_RECOVER_NOOP(view);
 
         if (view) {
             if (view->document() == document) {
                 setActiveSubWindow(subwindow);
                 return;
             }
         }
     }
 
     addViewAndNotifyLoadingCompleted(document);
 }
 
 KisView* KisMainWindow::addViewAndNotifyLoadingCompleted(KisDocument *document,
                                                          QMdiSubWindow *subWindow)
 {
     showWelcomeScreen(false); // see workaround in function header
 
     KisView *view = KisPart::instance()->createView(document, d->viewManager, this);
     addView(view, subWindow);
 
     emit guiLoadingFinished();
 
     return view;
 }
 
 QStringList KisMainWindow::showOpenFileDialog(bool isImporting)
 {
     KoFileDialog dialog(this, KoFileDialog::ImportFiles, "OpenDocument");
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setMimeTypeFilters(KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import));
     dialog.setCaption(isImporting ? i18n("Import Images") : i18n("Open Images"));
 
     return dialog.filenames();
 }
 
 // Separate from openDocument to handle async loading (remote URLs)
 void KisMainWindow::slotLoadCompleted()
 {
     KisDocument *newdoc = qobject_cast<KisDocument*>(sender());
     if (newdoc && newdoc->image()) {
         addViewAndNotifyLoadingCompleted(newdoc);
 
         disconnect(newdoc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
         disconnect(newdoc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 
         emit loadCompleted();
     }
 }
 
 void KisMainWindow::slotLoadCanceled(const QString & errMsg)
 {
     KisUsageLogger::log(QString("Loading canceled. Error:").arg(errMsg));
     if (!errMsg.isEmpty())   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     // ... can't delete the document, it's the one who emitted the signal...
 
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotLoadCompleted()));
     disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotLoadCanceled(QString)));
 }
 
 void KisMainWindow::slotSaveCanceled(const QString &errMsg)
 {
     KisUsageLogger::log(QString("Saving canceled. Error:").arg(errMsg));
     if (!errMsg.isEmpty()) {   // empty when canceled by user
         QMessageBox::critical(this, i18nc("@title:window", "Krita"), errMsg);
     }
     slotSaveCompleted();
 }
 
 void KisMainWindow::slotSaveCompleted()
 {
     KisUsageLogger::log(QString("Saving Completed"));
     KisDocument* doc = qobject_cast<KisDocument*>(sender());
     Q_ASSERT(doc);
     disconnect(doc, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     disconnect(doc, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     if (d->deferredClosingEvent) {
         KXmlGuiWindow::closeEvent(d->deferredClosingEvent);
     }
 }
 
 bool KisMainWindow::hackIsSaving() const
 {
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     return !l.owns_lock();
 }
 
 bool KisMainWindow::installBundle(const QString &fileName) const
 {
     QFileInfo from(fileName);
     QFileInfo to(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
     if (to.exists()) {
         QFile::remove(to.canonicalFilePath());
     }
     return QFile::copy(fileName, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation) + "/bundles/" + from.fileName());
 }
 
 QImage KisMainWindow::layoutThumbnail()
 {
     int size = 256;
     qreal scale = qreal(size)/qreal(qMax(geometry().width(), geometry().height()));
     QImage layoutThumbnail = QImage(qRound(geometry().width()*scale), qRound(geometry().height()*scale), QImage::Format_ARGB32);
     QPainter gc(&layoutThumbnail);
     gc.fillRect(0, 0, layoutThumbnail.width(), layoutThumbnail.height(), this->palette().dark());
 
     for (int childW = 0; childW< children().size(); childW++) {
         if (children().at(childW)->isWidgetType()) {
             QWidget *w = dynamic_cast<QWidget*>(children().at(childW));
 
             if (w->isVisible()) {
                 QRect wRect = QRectF(w->geometry().x()*scale
                                      , w->geometry().y()*scale
                                      , w->geometry().width()*scale
                                      , w->geometry().height()*scale
                                      ).toRect();
 
                 wRect = wRect.intersected(layoutThumbnail.rect().adjusted(-1, -1, -1, -1));
 
                 gc.setBrush(this->palette().window());
                 if (w == d->widgetStack) {
                     gc.setBrush(d->mdiArea->background());
                 }
                 gc.setPen(this->palette().windowText().color());
                 gc.drawRect(wRect);
             }
         }
     }
     gc.end();
     return layoutThumbnail;
 }
 
 bool KisMainWindow::saveDocument(KisDocument *document, bool saveas, bool isExporting)
 {
     if (!document) {
         return true;
     }
 
     /**
      * Make sure that we cannot enter this method twice!
      *
      * The lower level functions may call processEvents() so
      * double-entry is quite possible to achieve. Here we try to lock
      * the mutex, and if it is failed, just cancel saving.
      */
     StdLockableWrapper<QMutex> wrapper(&d->savingEntryMutex);
     std::unique_lock<StdLockableWrapper<QMutex>> l(wrapper, std::try_to_lock);
     if (!l.owns_lock()) return false;
 
     // no busy wait for saving because it is dangerous!
     KisDelayedSaveDialog dlg(document->image(), KisDelayedSaveDialog::SaveDialog, 0, this);
     dlg.blockIfImageIsBusy();
 
     if (dlg.result() == KisDelayedSaveDialog::Rejected) {
         return false;
     }
     else if (dlg.result() == KisDelayedSaveDialog::Ignored) {
         QMessageBox::critical(0,
                               i18nc("@title:window", "Krita"),
                               i18n("You are saving a file while the image is "
                                    "still rendering. The saved file may be "
                                    "incomplete or corrupted.\n\n"
                                    "Please select a location where the original "
                                    "file will not be overridden!"));
 
 
         saveas = true;
     }
 
     if (document->isRecovered()) {
         saveas = true;
     }
 
     if (document->url().isEmpty()) {
         saveas = true;
     }
 
     connect(document, SIGNAL(completed()), this, SLOT(slotSaveCompleted()));
     connect(document, SIGNAL(canceled(QString)), this, SLOT(slotSaveCanceled(QString)));
 
     QByteArray nativeFormat = document->nativeFormatMimeType();
     QByteArray oldMimeFormat = document->mimeType();
 
     QUrl suggestedURL = document->url();
 
     QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
 
     mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Export);
     if (!mimeFilter.contains(oldMimeFormat)) {
         dbgUI << "KisMainWindow::saveDocument no export filter for" << oldMimeFormat;
 
         // --- don't setOutputMimeType in case the user cancels the Save As
         // dialog and then tries to just plain Save ---
 
         // suggest a different filename extension (yes, we fortunately don't all live in a world of magic :))
         QString suggestedFilename = QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
 
         if (!suggestedFilename.isEmpty()) {  // ".kra" looks strange for a name
             suggestedFilename = suggestedFilename + "." + KisMimeDatabase::suffixesForMimeType(KIS_MIME_TYPE).first();
             suggestedURL = suggestedURL.adjusted(QUrl::RemoveFilename);
             suggestedURL.setPath(suggestedURL.path() + suggestedFilename);
         }
 
         // force the user to choose outputMimeType
         saveas = true;
     }
 
     bool ret = false;
 
     if (document->url().isEmpty() || isExporting || saveas) {
         // if you're just File/Save As'ing to change filter options you
         // don't want to be reminded about overwriting files etc.
         bool justChangingFilterOptions = false;
 
         KoFileDialog dialog(this, KoFileDialog::SaveFile, "SaveAs");
         dialog.setCaption(isExporting ? i18n("Exporting") : i18n("Saving As"));
 
         //qDebug() << ">>>>>" << isExporting << d->lastExportLocation << d->lastExportedFormat << QString::fromLatin1(document->mimeType());
 
         if (isExporting && !d->lastExportLocation.isEmpty() && !d->lastExportLocation.contains(QDir::tempPath())) {
 
             // Use the location where we last exported to, if it's set, as the opening location for the file dialog
             QString proposedPath = QFileInfo(d->lastExportLocation).absolutePath();
             // If the document doesn't have a filename yet, use the title
             QString proposedFileName = suggestedURL.isEmpty() ? document->documentInfo()->aboutInfo("title") :  QFileInfo(suggestedURL.toLocalFile()).completeBaseName();
             // Use the last mimetype we exported to by default
             QString proposedMimeType =  d->lastExportedFormat.isEmpty() ? "" : d->lastExportedFormat;
             QString proposedExtension = KisMimeDatabase::suffixesForMimeType(proposedMimeType).first().remove("*,");
 
             // Set the default dir: this overrides the one loaded from the config file, since we're exporting and the lastExportLocation is not empty
             dialog.setDefaultDir(proposedPath + "/" + proposedFileName + "." + proposedExtension, true);
             dialog.setMimeTypeFilters(mimeFilter, proposedMimeType);
         }
         else {
             // Get the last used location for saving
             KConfigGroup group =  KSharedConfig::openConfig()->group("File Dialogs");
             QString proposedPath = group.readEntry("SaveAs", "");
             // if that is empty, get the last used location for loading
             if (proposedPath.isEmpty()) {
                 proposedPath = group.readEntry("OpenDocument", "");
             }
             // If that is empty, too, use the Pictures location.
             if (proposedPath.isEmpty()) {
                 proposedPath = QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
             }
             // But only use that if the suggestedUrl, that is, the document's own url is empty, otherwise
             // open the location where the document currently is.
             dialog.setDefaultDir(suggestedURL.isEmpty() ? proposedPath : suggestedURL.toLocalFile(), true);
 
             // If exporting, default to all supported file types if user is exporting
             QByteArray default_mime_type = "";
             if (!isExporting) {
                 // otherwise use the document's mimetype, or if that is empty, kra, which is the savest.
                 default_mime_type = document->mimeType().isEmpty() ? nativeFormat : document->mimeType();
             }
             dialog.setMimeTypeFilters(mimeFilter, QString::fromLatin1(default_mime_type));
         }
 
         QUrl newURL = QUrl::fromUserInput(dialog.filename());
 
         if (newURL.isLocalFile()) {
             QString fn = newURL.toLocalFile();
             if (QFileInfo(fn).completeSuffix().isEmpty()) {
                 fn.append(KisMimeDatabase::suffixesForMimeType(nativeFormat).first());
                 newURL = QUrl::fromLocalFile(fn);
             }
         }
 
         if (document->documentInfo()->aboutInfo("title") == i18n("Unnamed")) {
             QString fn = newURL.toLocalFile();
             QFileInfo info(fn);
             document->documentInfo()->setAboutInfo("title", info.completeBaseName());
         }
 
         QByteArray outputFormat = nativeFormat;
 
         QString outputFormatString = KisMimeDatabase::mimeTypeForFile(newURL.toLocalFile(), false);
         outputFormat = outputFormatString.toLatin1();
 
 
         if (!isExporting) {
             justChangingFilterOptions = (newURL == document->url()) && (outputFormat == document->mimeType());
         }
         else {
             QString path = QFileInfo(d->lastExportLocation).absolutePath();
             QString filename = QFileInfo(document->url().toLocalFile()).completeBaseName();
             justChangingFilterOptions = (QFileInfo(newURL.toLocalFile()).absolutePath() == path)
                     && (QFileInfo(newURL.toLocalFile()).completeBaseName() == filename)
                     && (outputFormat == d->lastExportedFormat);
         }
 
         bool bOk = true;
         if (newURL.isEmpty()) {
             bOk = false;
         }
 
         if (bOk) {
             bool wantToSave = true;
 
             // don't change this line unless you know what you're doing :)
             if (!justChangingFilterOptions) {
                 if (!document->isNativeFormat(outputFormat))
                     wantToSave = true;
             }
 
             if (wantToSave) {
                 if (!isExporting) {  // Save As
                     ret = document->saveAs(newURL, outputFormat, true);
                     if (ret) {
                         dbgUI << "Successful Save As!";
                         KisPart::instance()->addRecentURLToAllMainWindows(newURL);
                         setReadWrite(true);
                     } else {
                         dbgUI << "Failed Save As!";
 
                     }
                 }
                 else { // Export
                     ret = document->exportDocument(newURL, outputFormat);
 
                     if (ret) {
                         d->lastExportLocation = newURL.toLocalFile();
                         d->lastExportedFormat = outputFormat;
                     }
                 }
 
             }   // if (wantToSave)  {
             else
                 ret = false;
         }   // if (bOk) {
         else
             ret = false;
     } else { // saving
         // We cannot "export" into the currently
         // opened document. We are not Gimp.
         KIS_ASSERT_RECOVER_NOOP(!isExporting);
 
         // be sure document has the correct outputMimeType!
         if (document->isModified()) {
             ret = document->save(true, 0);
         }
 
         if (!ret) {
             dbgUI << "Failed Save!";
         }
     }
 
     updateCaption();
 
     return ret;
 }
 
 void KisMainWindow::undo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->undo();
     }
 }
 
 void KisMainWindow::redo()
 {
     if (activeView()) {
         activeView()->document()->undoStack()->redo();
     }
 }
 
 void KisMainWindow::closeEvent(QCloseEvent *e)
 {
     if (hackIsSaving()) {
         e->setAccepted(false);
         return;
     }
 
     if (!KisPart::instance()->closingSession()) {
         QAction *action= d->viewManager->actionCollection()->action("view_show_canvas_only");
         if ((action) && (action->isChecked())) {
             action->setChecked(false);
         }
 
         // Save session when last window is closed
         if (KisPart::instance()->mainwindowCount() == 1) {
             bool closeAllowed = KisPart::instance()->closeSession();
 
             if (!closeAllowed) {
                 e->setAccepted(false);
                 return;
             }
         }
     }
 
     d->mdiArea->closeAllSubWindows();
 
     QList<QMdiSubWindow*> childrenList = d->mdiArea->subWindowList();
 
     if (childrenList.isEmpty()) {
         d->deferredClosingEvent = e;
         saveWindowState(true);
         d->canvasWindow->close();
     } else {
         e->setAccepted(false);
     }
 }
 
 void KisMainWindow::saveWindowSettings()
 {
     KSharedConfigPtr config =  KSharedConfig::openConfig();
 
     if (d->windowSizeDirty ) {
         dbgUI << "KisMainWindow::saveWindowSettings";
         KConfigGroup group = d->windowStateConfig;
         KWindowConfig::saveWindowSize(windowHandle(), group);
         config->sync();
         d->windowSizeDirty = false;
     }
 
     if (!d->activeView || d->activeView->document()) {
 
         // Save toolbar position into the config file of the app, under the doc's component name
         KConfigGroup group = d->windowStateConfig;
         saveMainWindowSettings(group);
 
         // Save collapsible state of dock widgets
         for (QMap<QString, QDockWidget*>::const_iterator i = d->dockWidgetsMap.constBegin();
              i != d->dockWidgetsMap.constEnd(); ++i) {
             if (i.value()->widget()) {
                 KConfigGroup dockGroup = group.group(QString("DockWidget ") + i.key());
                 dockGroup.writeEntry("Collapsed", i.value()->widget()->isHidden());
                 dockGroup.writeEntry("Locked", i.value()->property("Locked").toBool());
                 dockGroup.writeEntry("DockArea", (int) dockWidgetArea(i.value()));
                 dockGroup.writeEntry("xPosition", (int) i.value()->widget()->x());
                 dockGroup.writeEntry("yPosition", (int) i.value()->widget()->y());
 
                 dockGroup.writeEntry("width", (int) i.value()->widget()->width());
                 dockGroup.writeEntry("height", (int) i.value()->widget()->height());
             }
         }
 
     }
 
     KSharedConfig::openConfig()->sync();
     resetAutoSaveSettings(); // Don't let KMainWindow override the good stuff we wrote down
 
 }
 
 void KisMainWindow::resizeEvent(QResizeEvent * e)
 {
     d->windowSizeDirty = true;
     KXmlGuiWindow::resizeEvent(e);
 }
 
 void KisMainWindow::setActiveView(KisView* view)
 {
     d->activeView = view;
     updateCaption();
 
     if (d->undoActionsUpdateManager) {
         d->undoActionsUpdateManager->setCurrentDocument(view ? view->document() : 0);
     }
 
     d->viewManager->setCurrentView(view);
 
     KisWindowLayoutManager::instance()->activeDocumentChanged(view->document());
 }
 
 void KisMainWindow::dragMove(QDragMoveEvent * event)
 {
     QTabBar *tabBar = d->findTabBarHACK();
 
     if (!tabBar && d->mdiArea->viewMode() == QMdiArea::TabbedView) {
         qWarning() << "WARNING!!! Cannot find QTabBar in the main window! Looks like Qt has changed behavior. Drag & Drop between multiple tabs might not work properly (tabs will not switch automatically)!";
     }
 
     if (tabBar && tabBar->isVisible()) {
         QPoint pos = tabBar->mapFromGlobal(mapToGlobal(event->pos()));
         if (tabBar->rect().contains(pos)) {
             const int tabIndex = tabBar->tabAt(pos);
 
             if (tabIndex >= 0 && tabBar->currentIndex() != tabIndex) {
                 d->tabSwitchCompressor->start(tabIndex);
             }
         } else if (d->tabSwitchCompressor->isActive()) {
             d->tabSwitchCompressor->stop();
         }
     }
 }
 
 void KisMainWindow::dragLeave()
 {
     if (d->tabSwitchCompressor->isActive()) {
         d->tabSwitchCompressor->stop();
     }
 }
 
 
 void KisMainWindow::switchTab(int index)
 {
     QTabBar *tabBar = d->findTabBarHACK();
     if (!tabBar) return;
 
     tabBar->setCurrentIndex(index);
 }
 
 void KisMainWindow::showWelcomeScreen(bool show)
 {
     d->widgetStack->setCurrentIndex(!show);
 }
 
 void KisMainWindow::slotFileNew()
 {
     const QStringList mimeFilter = KisImportExportManager::supportedMimeTypes(KisImportExportManager::Import);
 
     KisOpenPane *startupWidget = new KisOpenPane(this, mimeFilter, QStringLiteral("templates/"));
     startupWidget->setWindowModality(Qt::WindowModal);
     startupWidget->setWindowTitle(i18n("Create new document"));
 
 
     KisConfig cfg(true);
 
     int w = cfg.defImageWidth();
     int h = cfg.defImageHeight();
     const double resolution = cfg.defImageResolution();
     const QString colorModel = cfg.defColorModel();
-    const QString colorDepth = cfg.defaultColorDepth();
+    const QString colorDepth = cfg.defColorDepth();
     const QString colorProfile = cfg.defColorProfile();
 
 
     CustomDocumentWidgetItem item;
     item.widget = new KisCustomImageWidget(startupWidget,
                                            w,
                                            h,
                                            resolution,
                                            colorModel,
                                            colorDepth,
                                            colorProfile,
                                            i18n("Unnamed"));
 
     item.icon = "document-new";
     item.title = i18n("Custom Document");
     startupWidget->addCustomDocumentWidget(item.widget, item.title, "Custom Document", item.icon);
 
     QSize sz = KisClipboard::instance()->clipSize();
     if (sz.isValid() && sz.width() != 0 && sz.height() != 0) {
         w = sz.width();
         h = sz.height();
     }
 
     item.widget = new KisImageFromClipboard(startupWidget,
                                             w,
                                             h,
                                             resolution,
                                             colorModel,
                                             colorDepth,
                                             colorProfile,
                                             i18n("Unnamed"));
 
     item.title = i18n("Create from Clipboard");
     item.icon = "tab-new";
 
     startupWidget->addCustomDocumentWidget(item.widget, item.title, "Create from ClipBoard", item.icon);
 
     // calls deleteLater
     connect(startupWidget, SIGNAL(documentSelected(KisDocument*)), KisPart::instance(), SLOT(startCustomDocument(KisDocument*)));
     // calls deleteLater
     connect(startupWidget, SIGNAL(openTemplate(QUrl)), KisPart::instance(), SLOT(openTemplate(QUrl)));
 
     startupWidget->exec();
 
     // Cancel calls deleteLater...
 
 }
 
 void KisMainWindow::slotImportFile()
 {
     dbgUI << "slotImportFile()";
     slotFileOpen(true);
 }
 
 
 void KisMainWindow::slotFileOpen(bool isImporting)
 {
 #ifndef Q_OS_ANDROID
     QStringList urls = showOpenFileDialog(isImporting);
 
     if (urls.isEmpty())
         return;
 
     Q_FOREACH (const QString& url, urls) {
 
         if (!url.isEmpty()) {
             OpenFlags flags = isImporting ? Import : None;
             bool res = openDocument(QUrl::fromLocalFile(url), flags);
             if (!res) {
                 warnKrita << "Loading" << url << "failed";
             }
         }
     }
 #else
     Q_UNUSED(isImporting)
 
     d->fileManager->openImportFile();
     connect(d->fileManager, SIGNAL(sigFileSelected(QString)), this, SLOT(slotFileSelected(QString)));
     connect(d->fileManager, SIGNAL(sigEmptyFilePath()), this, SLOT(slotEmptyFilePath()));
 #endif
 }
 
 void KisMainWindow::slotFileOpenRecent(const QUrl &url)
 {
     (void) openDocument(QUrl::fromLocalFile(url.toLocalFile()), None);
 }
 
 void KisMainWindow::slotFileSave()
 {
     if (saveDocument(d->activeView->document(), false, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotFileSaveAs()
 {
     if (saveDocument(d->activeView->document(), true, false)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotExportFile()
 {
     if (saveDocument(d->activeView->document(), true, true)) {
         emit documentSaved();
     }
 }
 
 void KisMainWindow::slotShowSessionManager() {
     KisPart::instance()->showSessionManager();
 }
 
 KoCanvasResourceProvider *KisMainWindow::resourceManager() const
 {
     return d->viewManager->canvasResourceProvider()->resourceManager();
 }
 
 int KisMainWindow::viewCount() const
 {
     return d->mdiArea->subWindowList().size();
 }
 
 const KConfigGroup &KisMainWindow::windowStateConfig() const
 {
     return d->windowStateConfig;
 }
 
 void KisMainWindow::saveWindowState(bool restoreNormalState)
 {
     if (restoreNormalState) {
         QAction *showCanvasOnly = d->viewManager->actionCollection()->action("view_show_canvas_only");
 
         if (showCanvasOnly && showCanvasOnly->isChecked()) {
             showCanvasOnly->setChecked(false);
         }
 
         d->windowStateConfig.writeEntry("ko_geometry", saveGeometry().toBase64());
         d->windowStateConfig.writeEntry("State", saveState().toBase64());
 
         if (!d->dockerStateBeforeHiding.isEmpty()) {
             restoreState(d->dockerStateBeforeHiding);
         }
 
         statusBar()->setVisible(true);
         menuBar()->setVisible(true);
 
         saveWindowSettings();
 
     } else {
         saveMainWindowSettings(d->windowStateConfig);
     }
 
 }
 
 bool KisMainWindow::restoreWorkspaceState(const QByteArray &state)
 {
     QByteArray oldState = saveState();
 
     // needed because otherwise the layout isn't correctly restored in some situations
     Q_FOREACH (QDockWidget *dock, dockWidgets()) {
         dock->toggleViewAction()->setEnabled(true);
         dock->hide();
     }
 
     bool success = KXmlGuiWindow::restoreState(state);
 
     if (!success) {
         KXmlGuiWindow::restoreState(oldState);
         return false;
     }
 
     return success;
 }
 
 bool KisMainWindow::restoreWorkspace(int workspaceId)
 {
 
     KisWorkspaceResourceSP workspace =
             KisResourceModelProvider::resourceModel(ResourceType::Workspaces)
             ->resourceForId(workspaceId).dynamicCast<KisWorkspaceResource>();
 
     bool success = restoreWorkspaceState(workspace->dockerState());
 
     if (activeKisView()) {
         activeKisView()->resourceProvider()->notifyLoadingWorkspace(workspace);
     }
 
     return success;
 }
 
 QByteArray KisMainWindow::borrowWorkspace(KisMainWindow *other)
 {
     QByteArray currentWorkspace = saveState();
 
     if (!d->workspaceBorrowedBy.isNull()) {
         if (other->id() == d->workspaceBorrowedBy) {
             // We're swapping our original workspace back
             d->workspaceBorrowedBy = QUuid();
             return currentWorkspace;
         } else {
             // Get our original workspace back before swapping with a third window
             KisMainWindow *borrower = KisPart::instance()->windowById(d->workspaceBorrowedBy);
             if (borrower) {
                 QByteArray originalLayout = borrower->borrowWorkspace(this);
                 borrower->restoreWorkspaceState(currentWorkspace);
 
                 d->workspaceBorrowedBy = other->id();
                 return originalLayout;
             }
         }
     }
 
     d->workspaceBorrowedBy = other->id();
     return currentWorkspace;
 }
 
 void KisMainWindow::swapWorkspaces(KisMainWindow *a, KisMainWindow *b)
 {
     QByteArray workspaceA = a->borrowWorkspace(b);
     QByteArray workspaceB = b->borrowWorkspace(a);
 
     a->restoreWorkspaceState(workspaceB);
     b->restoreWorkspaceState(workspaceA);
 }
 
 KisViewManager *KisMainWindow::viewManager() const
 {
     return d->viewManager;
 }
 
 void KisMainWindow::slotDocumentInfo()
 {
     if (!d->activeView->document())
         return;
 
     KoDocumentInfo *docInfo = d->activeView->document()->documentInfo();
 
     if (!docInfo)
         return;
 
     KoDocumentInfoDlg *dlg = d->activeView->document()->createDocumentInfoDialog(this, docInfo);
 
     if (dlg->exec()) {
         if (dlg->isDocumentSaved()) {
             d->activeView->document()->setModified(false);
         } else {
             d->activeView->document()->setModified(true);
         }
         d->activeView->document()->setTitleModified();
     }
 
     delete dlg;
 }
 
 bool KisMainWindow::slotFileCloseAll()
 {
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (subwin) {
             if(!subwin->close())
                 return false;
         }
     }
 
     updateCaption();
     return true;
 }
 
 void KisMainWindow::slotFileQuit()
 {
     // Do not close while KisMainWindow has the savingEntryMutex locked, bug409395.
     // After the background saving job is initiated, KisDocument blocks closing
     // while it saves itself.
     if (hackIsSaving()) {
         return;
     }
     KisPart::instance()->closeSession();
 }
 
 void KisMainWindow::importAnimation()
 {
     if (!activeView()) return;
 
     KisDocument *document = activeView()->document();
     if (!document) return;
 
     KisDlgImportImageSequence dlg(this, document);
 
     if (dlg.exec() == QDialog::Accepted) {
         QStringList files = dlg.files();
         int firstFrame = dlg.firstFrame();
         int step = dlg.step();
 
         KoUpdaterPtr updater =
                 !document->fileBatchMode() ? viewManager()->createUnthreadedUpdater(i18n("Import frames")) : 0;
         KisAnimationImporter importer(document->image(), updater);
         KisImportExportErrorCode status = importer.import(files, firstFrame, step);
 
         if (!status.isOk() && !status.isInternalError()) {
             QString msg = status.errorMessage();
             if (!msg.isEmpty())
                 QMessageBox::critical(0, i18nc("@title:window", "Krita"), i18n("Could not finish import animation:\n%1", msg));
         }
         activeView()->canvasBase()->refetchDataFromImage();
     }
 }
 
 void KisMainWindow::slotConfigureToolbars()
 {
     saveWindowState();
     KEditToolBar edit(factory(), this);
     connect(&edit, SIGNAL(newToolBarConfig()), this, SLOT(slotNewToolbarConfig()));
     (void) edit.exec();
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotResetConfigurations()
 {
     KisApplication *kisApp = static_cast<KisApplication*>(qApp);
     kisApp->askresetConfig();
 }
 
 void KisMainWindow::slotNewToolbarConfig()
 {
     applyMainWindowSettings(d->windowStateConfig);
 
     KXMLGUIFactory *factory = guiFactory();
     Q_UNUSED(factory);
 
     // Check if there's an active view
     if (!d->activeView)
         return;
 
     plugActionList("toolbarlist", d->toolbarList);
     applyToolBarLayout();
 }
 
 void KisMainWindow::slotToolbarToggled(bool toggle)
 {
     //dbgUI <<"KisMainWindow::slotToolbarToggled" << sender()->name() <<" toggle=" << true;
     // The action (sender) and the toolbar have the same name
     KToolBar * bar = toolBar(sender()->objectName());
     if (bar) {
         if (toggle) {
             bar->show();
         }
         else {
             bar->hide();
         }
 
         if (d->activeView && d->activeView->document()) {
             saveWindowState();
         }
     } else
         warnUI << "slotToolbarToggled : Toolbar " << sender()->objectName() << " not found!";
 }
 
 void KisMainWindow::viewFullscreen(bool fullScreen)
 {
     KisConfig cfg(false);
     cfg.setFullscreenMode(fullScreen);
 
     if (fullScreen) {
         setWindowState(windowState() | Qt::WindowFullScreen);   // set
     } else {
         setWindowState(windowState() & ~Qt::WindowFullScreen);   // reset
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::setMaxRecentItems(uint _number)
 {
     d->recentFiles->setMaxItems(_number);
 }
 
 QDockWidget* KisMainWindow::createDockWidget(KoDockFactoryBase* factory)
 {
     QDockWidget* dockWidget = 0;
     bool lockAllDockers = KisConfig(true).readEntry<bool>("LockAllDockerPanels", false);
 
     if (!d->dockWidgetsMap.contains(factory->id())) {
         dockWidget = factory->createDockWidget();
 
         // It is quite possible that a dock factory cannot create the dock; don't
         // do anything in that case.
         if (!dockWidget) {
             warnKrita << "Could not create docker for" << factory->id();
             return 0;
         }
 
         dockWidget->setFont(KoDockRegistry::dockFont());
         dockWidget->setObjectName(factory->id());
         dockWidget->setParent(this);
         if (lockAllDockers) {
             if (dockWidget->titleBarWidget()) {
                 dockWidget->titleBarWidget()->setVisible(false);
             }
             dockWidget->setFeatures(QDockWidget::NoDockWidgetFeatures);
         }
         if (dockWidget->widget() && dockWidget->widget()->layout())
             dockWidget->widget()->layout()->setContentsMargins(1, 1, 1, 1);
 
         Qt::DockWidgetArea side = Qt::RightDockWidgetArea;
         bool visible = true;
 
         switch (factory->defaultDockPosition()) {
         case KoDockFactoryBase::DockTornOff:
             dockWidget->setFloating(true); // position nicely?
             break;
         case KoDockFactoryBase::DockTop:
             side = Qt::TopDockWidgetArea; break;
         case KoDockFactoryBase::DockLeft:
             side = Qt::LeftDockWidgetArea; break;
         case KoDockFactoryBase::DockBottom:
             side = Qt::BottomDockWidgetArea; break;
         case KoDockFactoryBase::DockRight:
             side = Qt::RightDockWidgetArea; break;
         case KoDockFactoryBase::DockMinimized:
         default:
             side = Qt::RightDockWidgetArea;
             visible = false;
         }
 
         KConfigGroup group = d->windowStateConfig.group("DockWidget " + factory->id());
         side = static_cast<Qt::DockWidgetArea>(group.readEntry("DockArea", static_cast<int>(side)));
         if (side == Qt::NoDockWidgetArea) side = Qt::RightDockWidgetArea;
 
         addDockWidget(side, dockWidget);
         if (!visible) {
             dockWidget->hide();
         }
 
         d->dockWidgetsMap.insert(factory->id(), dockWidget);
     }
     else {
         dockWidget = d->dockWidgetsMap[factory->id()];
     }
 
 #ifdef Q_OS_MACOS
     dockWidget->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
     dockWidget->setFont(KoDockRegistry::dockFont());
 
     connect(dockWidget, SIGNAL(dockLocationChanged(Qt::DockWidgetArea)), this, SLOT(forceDockTabFonts()));
 
     return dockWidget;
 }
 
 void KisMainWindow::forceDockTabFonts()
 {
     Q_FOREACH (QObject *child, children()) {
         if (child->inherits("QTabBar")) {
             ((QTabBar *)child)->setFont(KoDockRegistry::dockFont());
         }
     }
 }
 
 void KisMainWindow::slotUpdateWidgetStyle()
 {
      KisConfig cfg(true);
      QString themeFromConfig = cfg.widgetStyle();
 
      Q_FOREACH (auto key, d->actionMap.keys()) { // find checked style to save to config
          if(d->actionMap.value(key)->isChecked()) {
             cfg.setWidgetStyle(key);
             qApp->setStyle(key);
          }
      }
 }
 
 QList<QDockWidget*> KisMainWindow::dockWidgets() const
 {
     return d->dockWidgetsMap.values();
 }
 
 QDockWidget* KisMainWindow::dockWidget(const QString &id)
 {
     if (!d->dockWidgetsMap.contains(id)) return 0;
     return d->dockWidgetsMap[id];
 }
 
 QList<KoCanvasObserverBase*> KisMainWindow::canvasObservers() const
 {
     QList<KoCanvasObserverBase*> observers;
 
     Q_FOREACH (QDockWidget *docker, dockWidgets()) {
         KoCanvasObserverBase *observer = dynamic_cast<KoCanvasObserverBase*>(docker);
         if (observer) {
             observers << observer;
         }
         else {
             warnKrita << docker << "is not a canvas observer";
         }
     }
     return observers;
 }
 
 
 void KisMainWindow::toggleDockersVisibility(bool visible)
 {
     if (!visible) {
         d->dockerStateBeforeHiding = saveState();
 
         Q_FOREACH (QObject* widget, children()) {
             if (widget->inherits("QDockWidget")) {
                 QDockWidget* dw = static_cast<QDockWidget*>(widget);
                 if (dw->isVisible()) {
                     dw->hide();
                 }
             }
         }
     }
     else {
         restoreState(d->dockerStateBeforeHiding);
     }
 }
 
 void KisMainWindow::slotDocumentTitleModified()
 {
     updateCaption();
 }
 
 
 void KisMainWindow::subWindowActivated()
 {
     bool enabled = (activeKisView() != 0);
 
     d->mdiCascade->setEnabled(enabled);
     d->mdiNextWindow->setEnabled(enabled);
     d->mdiPreviousWindow->setEnabled(enabled);
     d->mdiTile->setEnabled(enabled);
     d->close->setEnabled(enabled);
     d->closeAll->setEnabled(enabled);
 
     setActiveSubWindow(d->mdiArea->activeSubWindow());
     Q_FOREACH (QToolBar *tb, toolBars()) {
         if (tb->objectName() == "BrushesAndStuff") {
             tb->setEnabled(enabled);
         }
     }
 
     /**
      * Qt has a weirdness, it has hardcoded shortcuts added to an action
      * in the window menu. We need to reset the shortcuts for that menu
      * to nothing, otherwise the shortcuts cannot be made configurable.
      *
      * See: https://bugs.kde.org/show_bug.cgi?id=352205
      *      https://bugs.kde.org/show_bug.cgi?id=375524
      *      https://bugs.kde.org/show_bug.cgi?id=398729
      */
     QMdiSubWindow *subWindow = d->mdiArea->currentSubWindow();
     if (subWindow) {
         QMenu *menu = subWindow->systemMenu();
         if (menu && menu->actions().size() == 8) {
             Q_FOREACH (QAction *action, menu->actions()) {
                 action->setShortcut(QKeySequence());
 
             }
             menu->actions().last()->deleteLater();
         }
     }
 
     updateCaption();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::windowFocused()
 {
     /**
      * Notify selection manager so that it could update selection mask overlay
      */
     if (viewManager() && viewManager()->selectionManager()) {
         viewManager()->selectionManager()->selectionChanged();
     }
 
     KisPart *kisPart = KisPart::instance();
     KisWindowLayoutManager *layoutManager = KisWindowLayoutManager::instance();
     if (!layoutManager->primaryWorkspaceFollowsFocus()) return;
 
     QUuid primary = layoutManager->primaryWindowId();
     if (primary.isNull()) return;
 
     if (d->id == primary) {
         if (!d->workspaceBorrowedBy.isNull()) {
             KisMainWindow *borrower = kisPart->windowById(d->workspaceBorrowedBy);
             if (!borrower) return;
             swapWorkspaces(this, borrower);
         }
     } else {
         if (d->workspaceBorrowedBy == primary) return;
 
         KisMainWindow *primaryWindow = kisPart->windowById(primary);
         if (!primaryWindow) return;
         swapWorkspaces(this, primaryWindow);
     }
 }
 
 
 void KisMainWindow::updateWindowMenu()
 {
     QMenu *menu = d->windowMenu->menu();
     menu->clear();
 
     menu->addAction(d->newWindow);
     menu->addAction(d->documentMenu);
 
     QMenu *docMenu = d->documentMenu->menu();
     docMenu->clear();
 
     QFontMetrics fontMetrics = docMenu->fontMetrics();
 #if (QT_VERSION >= QT_VERSION_CHECK(5, 10, 0))
     QRect geom = this->geometry();
     QPoint p(geom.width() / 2 + geom.left(), geom.height() / 2 + geom.top());
     QScreen *screen = qApp->screenAt(p);
 
     int fileStringWidth = 300;
     if (screen) {
         fileStringWidth = int(screen->availableGeometry().width() * .40f);
     }
 #else
     int fileStringWidth = int(QApplication::desktop()->screenGeometry(this).width() * .40f);
 #endif
     Q_FOREACH (QPointer<KisDocument> doc, KisPart::instance()->documents()) {
         if (doc) {
             QString title = fontMetrics.elidedText(doc->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth);
             if (title.isEmpty() && doc->image()) {
                 title = doc->image()->objectName();
             }
             QAction *action = docMenu->addAction(title);
             action->setIcon(qApp->windowIcon());
             connect(action, SIGNAL(triggered()), d->documentMapper, SLOT(map()));
             d->documentMapper->setMapping(action, doc);
         }
     }
 
     menu->addAction(d->workspaceMenu);
     QMenu *workspaceMenu = d->workspaceMenu->menu();
     workspaceMenu->clear();
 
     KisResourceIterator resourceIterator(KisResourceModelProvider::resourceModel(ResourceType::Workspaces));
     KisMainWindow *m_this = this;
 
     while (resourceIterator.hasNext()) {
         KisResourceItemSP resource = resourceIterator.next();
         QAction *action = workspaceMenu->addAction(resource->name());
         connect(action, &QAction::triggered, this, [=]() {
             m_this->restoreWorkspace(resource->id());
         });
     }
     workspaceMenu->addSeparator();
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&Import Workspace...")),
             &QAction::triggered,
             this,
             [&]()
     {
         QStringList mimeTypes = KisResourceLoaderRegistry::instance()->mimeTypes(ResourceType::Workspaces);
         KoFileDialog dialog(0, KoFileDialog::OpenFile, "OpenDocument");
         dialog.setMimeTypeFilters(mimeTypes);
         dialog.setCaption(i18nc("@title:window", "Choose File to Add"));
         QString filename = dialog.filename();
 
         d->workspacemodel->importResourceFile(filename);
     });
 
     connect(workspaceMenu->addAction(i18nc("@action:inmenu", "&New Workspace...")),
             &QAction::triggered,
             [=]() {
         QString name;
         auto rserver = KisResourceServerProvider::instance()->workspaceServer();
 
         KisWorkspaceResourceSP workspace(new KisWorkspaceResource(""));
         workspace->setDockerState(m_this->saveState());
         d->viewManager->canvasResourceProvider()->notifySavingWorkspace(workspace);
         workspace->setValid(true);
         QString saveLocation = rserver->saveLocation();
 
         QFileInfo fileInfo(saveLocation + name + workspace->defaultFileExtension());
         bool fileOverWriteAccepted = false;
 
         while(!fileOverWriteAccepted) {
             name = QInputDialog::getText(this, i18nc("@title:window", "New Workspace..."),
                                                         i18nc("@label:textbox", "Name:"));
             if (name.isNull() || name.isEmpty()) {
                 return;
             } else {
                 fileInfo = QFileInfo(saveLocation + name.split(" ").join("_") + workspace->defaultFileExtension());
                 if (fileInfo.exists()) {
                     int res = QMessageBox::warning(this, i18nc("@title:window", "Name Already Exists")
                                                                 , i18n("The name '%1' already exists, do you wish to overwrite it?", name)
                                                                 , QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
                     if (res == QMessageBox::Yes) fileOverWriteAccepted = true;
                 } else {
                     fileOverWriteAccepted = true;
                 }
             }
         }
 
         workspace->setFilename(fileInfo.fileName());
         workspace->setName(name);
         rserver->addResource(workspace);
     });
 
     // TODO: What to do about delete?
     //    workspaceMenu->addAction(i18nc("@action:inmenu", "&Delete Workspace..."));
 
     menu->addSeparator();
     menu->addAction(d->close);
     menu->addAction(d->closeAll);
     if (d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         menu->addSeparator();
         menu->addAction(d->mdiTile);
         menu->addAction(d->mdiCascade);
     }
     menu->addSeparator();
     menu->addAction(d->mdiNextWindow);
     menu->addAction(d->mdiPreviousWindow);
     menu->addSeparator();
 
     QList<QMdiSubWindow *> windows = d->mdiArea->subWindowList();
     for (int i = 0; i < windows.size(); ++i) {
         QPointer<KisView>child = qobject_cast<KisView*>(windows.at(i)->widget());
         if (child && child->document()) {
             QString text;
             if (i < 9) {
                 text = i18n("&%1 %2", i + 1, fontMetrics.elidedText(child->document()->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth));
             }
             else {
                 text = i18n("%1 %2", i + 1, fontMetrics.elidedText(child->document()->url().toDisplayString(QUrl::PreferLocalFile), Qt::ElideMiddle, fileStringWidth));
             }
 
             QAction *action  = menu->addAction(text);
             action->setIcon(qApp->windowIcon());
             action->setCheckable(true);
             action->setChecked(child == activeKisView());
             connect(action, SIGNAL(triggered()), d->windowMapper, SLOT(map()));
             d->windowMapper->setMapping(action, windows.at(i));
         }
     }
 
     bool showMdiArea = windows.count( ) > 0;
     if (!showMdiArea) {
         showWelcomeScreen(true); // see workaround in function in header
         // keep the recent file list updated when going back to welcome screen
         reloadRecentFileList();
         d->welcomePage->populateRecentDocuments();
     }
 
     // enable/disable the toolbox docker if there are no documents open
     Q_FOREACH (QObject* widget, children()) {
         if (widget->inherits("QDockWidget")) {
             QDockWidget* dw = static_cast<QDockWidget*>(widget);
 
             if ( dw->objectName() == "ToolBox") {
                 dw->setEnabled(showMdiArea);
             }
         }
     }
 
     updateCaption();
 }
 
 void KisMainWindow::updateSubwindowFlags()
 {
     bool onlyOne = false;
     if (d->mdiArea->subWindowList().size() == 1 && d->mdiArea->viewMode() == QMdiArea::SubWindowView) {
         onlyOne = true;
     }
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         if (onlyOne) {
             subwin->setWindowFlags(subwin->windowFlags() | Qt::FramelessWindowHint);
             subwin->showMaximized();
         } else {
             subwin->setWindowFlags((subwin->windowFlags() | Qt::FramelessWindowHint) ^ Qt::FramelessWindowHint);
         }
     }
 }
 
 void KisMainWindow::setActiveSubWindow(QWidget *window)
 {
     if (!window) return;
     QMdiSubWindow *subwin = qobject_cast<QMdiSubWindow *>(window);
     //dbgKrita << "setActiveSubWindow();" << subwin << d->activeSubWindow;
 
     if (subwin && subwin != d->activeSubWindow) {
         KisView *view = qobject_cast<KisView *>(subwin->widget());
         //dbgKrita << "\t" << view << activeView();
         if (view && view != activeView()) {
             d->mdiArea->setActiveSubWindow(subwin);
             setActiveView(view);
         }
         d->activeSubWindow = subwin;
     }
     updateWindowMenu();
     d->actionManager()->updateGUI();
 }
 
 void KisMainWindow::configChanged()
 {
     KisConfig cfg(true);
     QMdiArea::ViewMode viewMode = (QMdiArea::ViewMode)cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView);
     d->mdiArea->setViewMode(viewMode);
     Q_FOREACH (QMdiSubWindow *subwin, d->mdiArea->subWindowList()) {
         subwin->setOption(QMdiSubWindow::RubberBandMove, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
         subwin->setOption(QMdiSubWindow::RubberBandResize, cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
         /**
          * Dirty workaround for a bug in Qt (checked on Qt 5.6.1):
          *
          * If you make a window "Show on top" and then switch to the tabbed mode
          * the window will continue to be painted in its initial "mid-screen"
          * position. It will persist here until you explicitly switch to its tab.
          */
         if (viewMode == QMdiArea::TabbedView) {
             Qt::WindowFlags oldFlags = subwin->windowFlags();
             Qt::WindowFlags flags = oldFlags;
 
             flags &= ~Qt::WindowStaysOnTopHint;
             flags &= ~Qt::WindowStaysOnBottomHint;
 
             if (flags != oldFlags) {
                 subwin->setWindowFlags(flags);
                 subwin->showMaximized();
             }
         }
     }
 #ifdef Q_OS_MACOS
     updateSubwindowFlags();
 #endif
 
     KConfigGroup group( KSharedConfig::openConfig(), "theme");
     d->themeManager->setCurrentTheme(group.readEntry("Theme", "Krita dark"));
     d->actionManager()->updateGUI();
 
     QString s = cfg.getMDIBackgroundColor();
     KoColor c = KoColor::fromXML(s);
     QBrush brush(c.toQColor());
     d->mdiArea->setBackground(brush);
 
     QString backgroundImage = cfg.getMDIBackgroundImage();
     if (backgroundImage != "") {
         QImage image(backgroundImage);
         QBrush brush(image);
         d->mdiArea->setBackground(brush);
     }
 
     d->mdiArea->update();
 }
 
 KisView* KisMainWindow::newView(QObject *document, QMdiSubWindow *subWindow)
 {
     KisDocument *doc = qobject_cast<KisDocument*>(document);
     KisView *view = addViewAndNotifyLoadingCompleted(doc, subWindow);
     d->actionManager()->updateGUI();
 
     return view;
 }
 
 void KisMainWindow::newWindow()
 {
     KisMainWindow *mainWindow = KisPart::instance()->createMainWindow();
     mainWindow->initializeGeometry();
     mainWindow->show();
 }
 
 void KisMainWindow::closeCurrentWindow()
 {
     if (d->mdiArea->currentSubWindow()) {
         d->mdiArea->currentSubWindow()->close();
         d->actionManager()->updateGUI();
     }
 }
 
 void KisMainWindow::checkSanity()
 {
     // print error if the lcms engine is not available
     if (!KoColorSpaceEngineRegistry::instance()->contains("icc")) {
         // need to wait 1 event since exiting here would not work.
         m_errorMessage = i18n("The Krita LittleCMS color management plugin is not installed. Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 
     KisPaintOpPresetResourceServer * rserver = KisResourceServerProvider::instance()->paintOpPresetServer();
     if (rserver->resourceCount() == 0) {
         m_errorMessage = i18n("Krita cannot find any brush presets! Krita will quit now.");
         m_dieOnError = true;
         QTimer::singleShot(0, this, SLOT(showErrorAndDie()));
         return;
     }
 }
 
 void KisMainWindow::showErrorAndDie()
 {
     QMessageBox::critical(0, i18nc("@title:window", "Installation error"), m_errorMessage);
     if (m_dieOnError) {
         exit(10);
     }
 }
 
 void KisMainWindow::showAboutApplication()
 {
     KisAboutApplication dlg(this);
     dlg.exec();
 }
 
 QPointer<KisView> KisMainWindow::activeKisView()
 {
     if (!d->mdiArea) return 0;
     QMdiSubWindow *activeSubWindow = d->mdiArea->activeSubWindow();
     //dbgKrita << "activeKisView" << activeSubWindow;
     if (!activeSubWindow) return 0;
     return qobject_cast<KisView*>(activeSubWindow->widget());
 }
 
 void KisMainWindow::newOptionWidgets(KoCanvasController *controller, const QList<QPointer<QWidget> > &optionWidgetList)
 {
     KIS_ASSERT_RECOVER_NOOP(controller == KoToolManager::instance()->activeCanvasController());
     bool isOurOwnView = false;
 
     Q_FOREACH (QPointer<KisView> view, KisPart::instance()->views()) {
         if (view && view->canvasController() == controller) {
             isOurOwnView = view->mainWindow() == this;
         }
     }
 
     if (!isOurOwnView) return;
 
     Q_FOREACH (QWidget *w, optionWidgetList) {
 #ifdef Q_OS_MACOS
         w->setAttribute(Qt::WA_MacSmallSize, true);
 #endif
         w->setFont(KoDockRegistry::dockFont());
     }
 
     if (d->toolOptionsDocker) {
         d->toolOptionsDocker->setOptionWidgets(optionWidgetList);
     }
     else {
         d->viewManager->paintOpBox()->newOptionWidgets(optionWidgetList);
     }
 }
 
 void KisMainWindow::createActions()
 {
     KisActionManager *actionManager = d->actionManager();
 
 
 
     actionManager->createStandardAction(KStandardAction::New, this, SLOT(slotFileNew()));
     actionManager->createStandardAction(KStandardAction::Open, this, SLOT(slotFileOpen()));
     actionManager->createStandardAction(KStandardAction::Quit, this, SLOT(slotFileQuit()));
     actionManager->createStandardAction(KStandardAction::ConfigureToolbars, this, SLOT(slotConfigureToolbars()));
     d->fullScreenMode = actionManager->createStandardAction(KStandardAction::FullScreen, this, SLOT(viewFullscreen(bool)));
 
     d->recentFiles = KStandardAction::openRecent(this, SLOT(slotFileOpenRecent(QUrl)), actionCollection());
     connect(d->recentFiles, SIGNAL(recentListCleared()), this, SLOT(saveRecentFiles()));
     KSharedConfigPtr configPtr =  KSharedConfig::openConfig();
     d->recentFiles->loadEntries(configPtr->group("RecentFiles"));
 
     d->saveAction = actionManager->createStandardAction(KStandardAction::Save, this, SLOT(slotFileSave()));
     d->saveAction->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->saveActionAs = actionManager->createStandardAction(KStandardAction::SaveAs, this, SLOT(slotFileSaveAs()));
     d->saveActionAs->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undo = actionManager->createStandardAction(KStandardAction::Undo, this, SLOT(undo()));
     d->undo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->redo = actionManager->createStandardAction(KStandardAction::Redo, this, SLOT(redo()));
     d->redo->setActivationFlags(KisAction::ACTIVE_IMAGE);
 
     d->undoActionsUpdateManager.reset(new KisUndoActionsUpdateManager(d->undo, d->redo));
     d->undoActionsUpdateManager->setCurrentDocument(d->activeView ? d->activeView->document() : 0);
 
     d->importAnimation  = actionManager->createAction("file_import_animation");
     connect(d->importAnimation, SIGNAL(triggered()), this, SLOT(importAnimation()));
 
     d->closeAll = actionManager->createAction("file_close_all");
     connect(d->closeAll, SIGNAL(triggered()), this, SLOT(slotFileCloseAll()));
 
     d->importFile  = actionManager->createAction("file_import_file");
     connect(d->importFile, SIGNAL(triggered(bool)), this, SLOT(slotImportFile()));
 
     d->exportFile  = actionManager->createAction("file_export_file");
     connect(d->exportFile, SIGNAL(triggered(bool)), this, SLOT(slotExportFile()));
 
     /* The following entry opens the document information dialog.  Since the action is named so it
         intends to show data this entry should not have a trailing ellipses (...).  */
     d->showDocumentInfo  = actionManager->createAction("file_documentinfo");
     connect(d->showDocumentInfo, SIGNAL(triggered(bool)), this, SLOT(slotDocumentInfo()));
 
 
     d->themeManager->setThemeMenuAction(new KActionMenu(i18nc("@action:inmenu", "&Themes"), this));
     d->themeManager->registerThemeActions(actionCollection());
     connect(d->themeManager, SIGNAL(signalThemeChanged()), this, SLOT(slotThemeChanged()));
 
 
     connect(d->themeManager, SIGNAL(signalThemeChanged()), d->welcomePage, SLOT(slotUpdateThemeColors()));
 
     d->toggleDockers = actionManager->createAction("view_toggledockers");
     KisConfig(true).showDockers(true);
     d->toggleDockers->setChecked(true);
     connect(d->toggleDockers, SIGNAL(toggled(bool)), SLOT(toggleDockersVisibility(bool)));
 
     d->resetConfigurations  = actionManager->createAction("reset_configurations");
     connect(d->resetConfigurations, SIGNAL(triggered()), this, SLOT(slotResetConfigurations()));
 
     d->toggleDetachCanvas = actionManager->createAction("view_detached_canvas");
     d->toggleDetachCanvas->setChecked(false);
     connect(d->toggleDetachCanvas, SIGNAL(toggled(bool)), SLOT(setCanvasDetached(bool)));
     setCanvasDetached(false);
 
     actionCollection()->addAction("settings_dockers_menu", d->dockWidgetMenu);
     actionCollection()->addAction("window", d->windowMenu);
 
     actionCollection()->addAction("style_menu", d->styleMenu); // for widget styles: breeze, fusion, etc
 
     d->mdiCascade = actionManager->createAction("windows_cascade");
     connect(d->mdiCascade, SIGNAL(triggered()), d->mdiArea, SLOT(cascadeSubWindows()));
 
     d->mdiTile = actionManager->createAction("windows_tile");
     connect(d->mdiTile, SIGNAL(triggered()), d->mdiArea, SLOT(tileSubWindows()));
 
     d->mdiNextWindow = actionManager->createAction("windows_next");
     connect(d->mdiNextWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activateNextSubWindow()));
 
     d->mdiPreviousWindow = actionManager->createAction("windows_previous");
     connect(d->mdiPreviousWindow, SIGNAL(triggered()), d->mdiArea, SLOT(activatePreviousSubWindow()));
 
     d->newWindow = actionManager->createAction("view_newwindow");
     connect(d->newWindow, SIGNAL(triggered(bool)), this, SLOT(newWindow()));
 
     d->close = actionManager->createStandardAction(KStandardAction::Close, this, SLOT(closeCurrentWindow()));
 
     d->showSessionManager = actionManager->createAction("file_sessions");
     connect(d->showSessionManager, SIGNAL(triggered(bool)), this, SLOT(slotShowSessionManager()));
 
     actionManager->createStandardAction(KStandardAction::Preferences, this, SLOT(slotPreferences()));
 
     for (int i = 0; i < 2; i++) {
         d->expandingSpacers[i] = new KisAction(i18n("Expanding Spacer"));
         d->expandingSpacers[i]->setDefaultWidget(new QWidget(this));
         d->expandingSpacers[i]->defaultWidget()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
         actionManager->addAction(QString("expanding_spacer_%1").arg(i), d->expandingSpacers[i]);
     }
 }
 
 void KisMainWindow::applyToolBarLayout()
 {
     const bool isPlastiqueStyle = style()->objectName() == "plastique";
 
     Q_FOREACH (KToolBar *toolBar, toolBars()) {
         toolBar->layout()->setSpacing(4);
         if (isPlastiqueStyle) {
             toolBar->setContentsMargins(0, 0, 0, 2);
         }
         //Hide text for buttons with an icon in the toolbar
         Q_FOREACH (QAction *ac, toolBar->actions()){
             if (ac->icon().pixmap(QSize(1,1)).isNull() == false){
                 ac->setPriority(QAction::LowPriority);
             }else {
                 ac->setIcon(QIcon());
             }
         }
     }
 }
 
 void KisMainWindow::initializeGeometry()
 {
     // if the user didn's specify the geometry on the command line (does anyone do that still?),
     // we first figure out some good default size and restore the x,y position. See bug 285804Z.
     KConfigGroup cfg = d->windowStateConfig;
     QByteArray geom = QByteArray::fromBase64(cfg.readEntry("ko_geometry", QByteArray()));
     if (!restoreGeometry(geom)) {
         const int scnum = QApplication::desktop()->screenNumber(parentWidget());
         QRect desk = QGuiApplication::screens().at(scnum)->availableVirtualGeometry();
 
         quint32 x = desk.x();
         quint32 y = desk.y();
         quint32 w = 0;
         quint32 h = 0;
 
         // Default size -- maximize on small screens, something useful on big screens
         const int deskWidth = desk.width();
         if (deskWidth > 1024) {
             // a nice width, and slightly less than total available
             // height to compensate for the window decs
             w = (deskWidth / 3) * 2;
             h = (desk.height() / 3) * 2;
         }
         else {
             w = desk.width();
             h = desk.height();
         }
 
         x += (desk.width() - w) / 2;
         y += (desk.height() - h) / 2;
 
         move(x,y);
         setGeometry(geometry().x(), geometry().y(), w, h);
     }
     d->fullScreenMode->setChecked(isFullScreen());
 }
 
 void KisMainWindow::showManual()
 {
     QDesktopServices::openUrl(QUrl("https://docs.krita.org"));
 }
 
 void KisMainWindow::windowScreenChanged(QScreen *screen)
 {
     emit screenChanged();
     d->screenConnectionsStore.clear();
     d->screenConnectionsStore.addConnection(screen, SIGNAL(physicalDotsPerInchChanged(qreal)),
                                             this, SIGNAL(screenChanged()));
 }
 
 void KisMainWindow::slotXmlGuiMakingChanges(bool finished)
 {
     if (finished) {
         subWindowActivated();
     }
 }
 
 
 
 #include <moc_KisMainWindow.cpp>
diff --git a/libs/ui/dialogs/kis_dlg_preferences.cc b/libs/ui/dialogs/kis_dlg_preferences.cc
index d4e1109305..f04ceb4e94 100644
--- a/libs/ui/dialogs/kis_dlg_preferences.cc
+++ b/libs/ui/dialogs/kis_dlg_preferences.cc
@@ -1,1811 +1,1824 @@
 /*
  *  preferencesdlg.cc - part of KImageShop
  *
  *  Copyright (c) 1999 Michael Koch <koch@kde.org>
  *  Copyright (c) 2003-2011 Boudewijn Rempt <boud@valdyas.org>
  *
  *  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; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_dlg_preferences.h"
 
 #include <config-hdr.h>
 #include <opengl/kis_opengl.h>
 
 #include <QBitmap>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QCursor>
 #include <QDesktopWidget>
 #include <QFileDialog>
 #include <QFormLayout>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMdiArea>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QSettings>
 #include <QSlider>
 #include <QStandardPaths>
 #include <QThread>
 #include <QToolButton>
 #include <QStyleFactory>
 
 #include <KisApplication.h>
 #include <KisDocument.h>
 #include <kis_icon.h>
 #include <KisPart.h>
+#include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 #include <KoColorSpaceEngine.h>
 #include <KoConfigAuthorPage.h>
 #include <KoConfig.h>
 #include <KoFileDialog.h>
 #include "KoID.h"
 #include <KoVBox.h>
 
 #include <klocalizedstring.h>
 #include <kformat.h>
 #include <kundo2stack.h>
 #include <KoResourcePaths.h>
 
 #include <KisResourceCacheDb.h>
 #include <KisResourceLocator.h>
 
 #include "KisProofingConfiguration.h"
 #include "KoColorConversionTransformation.h"
 #include "kis_action_registry.h"
 #include <kis_image.h>
 #include <KisSqueezedComboBox.h>
 #include "kis_clipboard.h"
 #include "widgets/kis_cmb_idlist.h"
 #include "KoColorSpace.h"
 #include "KoColorSpaceRegistry.h"
 #include "kis_canvas_resource_provider.h"
 #include "kis_color_manager.h"
 #include "kis_config.h"
 #include "kis_cursor.h"
 #include "kis_image_config.h"
 #include "kis_preference_set_registry.h"
 
 #include "kis_file_name_requester.h"
 
 #include "slider_and_spin_box_sync.h"
 
 // for the performance update
 #include <kis_cubic_curve.h>
 #include <kis_signals_blocker.h>
 
 #include "input/config/kis_input_configuration_page.h"
 #include "input/wintab/drawpile_tablettester/tablettester.h"
 
 #ifdef Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #   ifndef USE_QT_TABLET_WINDOWS
 #       include <kis_tablet_support_win8.h>
 #   endif
 #include "config-high-dpi-scale-factor-rounding-policy.h"
 #endif
 
 struct BackupSuffixValidator : public QValidator {
     BackupSuffixValidator(QObject *parent)
         : QValidator(parent)
         , invalidCharacters(QStringList()
                             << "0" << "1" << "2" << "3" << "4" << "5" << "6" << "7" << "8" << "9"
                             << "/" << "\\" << ":" << ";" << " ")
     {}
 
     ~BackupSuffixValidator() override {}
 
     const QStringList invalidCharacters;
 
     State validate(QString &line, int &/*pos*/) const override
     {
         Q_FOREACH(const QString invalidChar, invalidCharacters) {
             if (line.contains(invalidChar)) {
                 return Invalid;
             }
         }
         return Acceptable;
     }
 };
 
 
 GeneralTab::GeneralTab(QWidget *_parent, const char *_name)
     : WdgGeneralSettings(_parent, _name)
 {
     KisConfig cfg(true);
 
     //
     // Cursor Tab
     //
     m_cmbCursorShape->addItem(i18n("No Cursor"));
     m_cmbCursorShape->addItem(i18n("Tool Icon"));
     m_cmbCursorShape->addItem(i18n("Arrow"));
     m_cmbCursorShape->addItem(i18n("Small Circle"));
     m_cmbCursorShape->addItem(i18n("Crosshair"));
     m_cmbCursorShape->addItem(i18n("Triangle Righthanded"));
     m_cmbCursorShape->addItem(i18n("Triangle Lefthanded"));
     m_cmbCursorShape->addItem(i18n("Black Pixel"));
     m_cmbCursorShape->addItem(i18n("White Pixel"));
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle());
 
     m_cmbOutlineShape->addItem(i18n("No Outline"));
     m_cmbOutlineShape->addItem(i18n("Circle Outline"));
     m_cmbOutlineShape->addItem(i18n("Preview Outline"));
     m_cmbOutlineShape->addItem(i18n("Tilt Outline"));
 
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle());
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting());
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline());
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor());
     cursorColorBtutton->setColor(cursorColor);
 
     //
     // Window Tab
     //
     m_cmbMDIType->setCurrentIndex(cfg.readEntry<int>("mdi_viewmode", (int)QMdiArea::TabbedView));
 
     m_backgroundimage->setText(cfg.getMDIBackgroundImage());
     connect(m_bnFileName, SIGNAL(clicked()), SLOT(getBackgroundImage()));
     connect(clearBgImageButton, SIGNAL(clicked()), SLOT(clearBackgroundImage()));
 
     QString xml = cfg.getMDIBackgroundColor();
     KoColor mdiColor = KoColor::fromXML(xml);
     m_mdiColor->setColor(mdiColor);
 
     m_chkRubberBand->setChecked(cfg.readEntry<int>("mdi_rubberband", cfg.useOpenGL()));
 
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages());
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     m_chkHiDPI->setChecked(kritarc.value("EnableHiDPI", true).toBool());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(kritarc.value("EnableHiDPIFractionalScaling", true).toBool());
 #else
     m_chkHiDPIFractionalScaling->setVisible(false);
 #endif
     chkUsageLogging->setChecked(kritarc.value("LogUsage", true).toBool());
 
 
     //
     // Tools tab
     //
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker());
     cmbFlowMode->setCurrentIndex((int)!cfg.readEntry<bool>("useCreamyAlphaDarken", true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt());
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas());
     chkEnableTouchRotation->setChecked(!cfg.disableTouchRotation());
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste());
 
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled());
 
     m_cmbKineticScrollingGesture->addItem(i18n("On Touch Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Click Drag"));
     m_cmbKineticScrollingGesture->addItem(i18n("On Middle-Click Drag"));
     //m_cmbKineticScrollingGesture->addItem(i18n("On Right Click Drag"));
 
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture());
     m_kineticScrollingSensitivitySlider->setRange(0, 100);
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity());
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars());
 
     //
     // File handling
     //
     int autosaveInterval = cfg.autoSaveInterval();
     //convert to minutes
     m_autosaveSpinBox->setValue(autosaveInterval / 60);
     m_autosaveCheckBox->setChecked(autosaveInterval > 0);
     chkHideAutosaveFiles->setChecked(cfg.readEntry<bool>("autosavefileshidden", true));
 
     m_chkCompressKra->setChecked(cfg.compressKra());
     chkZip64->setChecked(cfg.useZip64());
     m_chkTrimKra->setChecked(cfg.trimKra());
 
     m_backupFileCheckBox->setChecked(cfg.backupFile());
     cmbBackupFileLocation->setCurrentIndex(cfg.readEntry<int>("backupfilelocation", 0));
     txtBackupFileSuffix->setText(cfg.readEntry<QString>("backupfilesuffix", "~"));
     QValidator *validator = new BackupSuffixValidator(txtBackupFileSuffix);
     txtBackupFileSuffix->setValidator(validator);
     intNumBackupFiles->setValue(cfg.readEntry<int>("numberofbackupfiles", 1));
 
     //
     // Miscellaneous
     //
     cmbStartupSession->addItem(i18n("Open default window"));
     cmbStartupSession->addItem(i18n("Load previous session"));
     cmbStartupSession->addItem(i18n("Show session manager"));
     cmbStartupSession->setCurrentIndex(cfg.sessionOnStartup());
 
     chkSaveSessionOnQuit->setChecked(cfg.saveSessionOnQuit(false));
 
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport());
 
     m_undoStackSize->setValue(cfg.undoStackLimit());
 
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets());
 
     chkShowRootLayer->setChecked(cfg.showRootLayer());
 
     m_chkAutoPin->setChecked(cfg.autoPinLayersToTimeline());
 
     KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
     bool dontUseNative = true;
 #ifdef Q_OS_UNIX
     if (qgetenv("XDG_CURRENT_DESKTOP") == "KDE") {
         dontUseNative = false;
     }
 #endif
 #ifdef Q_OS_WIN
     dontUseNative = false;
 #endif
     m_chkNativeFileDialog->setChecked(!group.readEntry("DontUseNativeFileDialog", dontUseNative));
 
     intMaxBrushSize->setValue(cfg.readEntry("maximumBrushSize", 1000));
 
     //
     // Resources
     //
     m_urlCacheDbLocation->setMode(KoFileDialog::OpenDirectory);
     m_urlCacheDbLocation->setConfigurationName("cachedb_location");
     m_urlCacheDbLocation->setFileName(cfg.readEntry<QString>(KisResourceCacheDb::dbLocationKey, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)));
 
     m_urlResourceFolder->setMode(KoFileDialog::OpenDirectory);
     m_urlResourceFolder->setConfigurationName("resource_directory");
     m_urlResourceFolder->setFileName(cfg.readEntry<QString>(KisResourceLocator::resourceLocationKey, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)));
 }
 
 void GeneralTab::setDefault()
 {
     KisConfig cfg(true);
 
     m_cmbCursorShape->setCurrentIndex(cfg.newCursorStyle(true));
     m_cmbOutlineShape->setCurrentIndex(cfg.newOutlineStyle(true));
     chkShowRootLayer->setChecked(cfg.showRootLayer(true));
     m_autosaveCheckBox->setChecked(cfg.autoSaveInterval(true) > 0);
     //convert to minutes
     m_autosaveSpinBox->setValue(cfg.autoSaveInterval(true) / 60);
     chkHideAutosaveFiles->setChecked(true);
 
     m_undoStackSize->setValue(cfg.undoStackLimit(true));
 
     m_backupFileCheckBox->setChecked(cfg.backupFile(true));
     cmbBackupFileLocation->setCurrentIndex(0);
     txtBackupFileSuffix->setText("~");
     intNumBackupFiles->setValue(1);
 
     m_showOutlinePainting->setChecked(cfg.showOutlineWhilePainting(true));
     m_changeBrushOutline->setChecked(!cfg.forceAlwaysFullSizedOutline(true));
 
     m_chkNativeFileDialog->setChecked(false);
     intMaxBrushSize->setValue(1000);
 
     m_cmbMDIType->setCurrentIndex((int)QMdiArea::TabbedView);
     m_chkRubberBand->setChecked(cfg.useOpenGL(true));
     m_favoritePresetsSpinBox->setValue(cfg.favoritePresets(true));
     KoColor mdiColor;
     mdiColor.fromXML(cfg.getMDIBackgroundColor(true));
     m_mdiColor->setColor(mdiColor);
     m_backgroundimage->setText(cfg.getMDIBackgroundImage(true));
     m_chkCanvasMessages->setChecked(cfg.showCanvasMessages(true));
     m_chkCompressKra->setChecked(cfg.compressKra(true));
     m_chkTrimKra->setChecked(cfg.trimKra(true));
     chkZip64->setChecked(cfg.useZip64(true));
     m_chkHiDPI->setChecked(false);
     m_chkHiDPI->setChecked(true);
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
     m_chkHiDPIFractionalScaling->setChecked(true);
 #endif
     chkUsageLogging->setChecked(true);
     m_radioToolOptionsInDocker->setChecked(cfg.toolOptionsInDocker(true));
     cmbFlowMode->setCurrentIndex(0);
     m_groupBoxKineticScrollingSettings->setChecked(cfg.kineticScrollingEnabled(true));
     m_cmbKineticScrollingGesture->setCurrentIndex(cfg.kineticScrollingGesture(true));
     m_kineticScrollingSensitivitySlider->setValue(cfg.kineticScrollingSensitivity(true));
     m_chkKineticScrollingHideScrollbars->setChecked(cfg.kineticScrollingHiddenScrollbars(true));
     m_chkSwitchSelectionCtrlAlt->setChecked(cfg.switchSelectionCtrlAlt(true));
     chkEnableTouch->setChecked(!cfg.disableTouchOnCanvas(true));
     chkEnableTouchRotation->setChecked(!cfg.disableTouchRotation(true));
     chkEnableTranformToolAfterPaste->setChecked(cfg.activateTransformToolAfterPaste(true));
     m_chkConvertOnImport->setChecked(cfg.convertToImageColorspaceOnImport(true));
 
     KoColor cursorColor(KoColorSpaceRegistry::instance()->rgb8());
     cursorColor.fromQColor(cfg.getCursorMainColor(true));
     cursorColorBtutton->setColor(cursorColor);
 
     m_chkAutoPin->setChecked(cfg.autoPinLayersToTimeline(true));
 
     m_urlCacheDbLocation->setFileName(cfg.readEntry<QString>(KisResourceCacheDb::dbLocationKey, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)));
     m_urlResourceFolder->setFileName(cfg.readEntry<QString>(KisResourceLocator::resourceLocationKey, QStandardPaths::writableLocation(QStandardPaths::AppDataLocation)));
 }
 
 CursorStyle GeneralTab::cursorStyle()
 {
     return (CursorStyle)m_cmbCursorShape->currentIndex();
 }
 
 OutlineStyle GeneralTab::outlineStyle()
 {
     return (OutlineStyle)m_cmbOutlineShape->currentIndex();
 }
 
 KisConfig::SessionOnStartup GeneralTab::sessionOnStartup() const
 {
     return (KisConfig::SessionOnStartup)cmbStartupSession->currentIndex();
 }
 
 bool GeneralTab::saveSessionOnQuit() const
 {
     return chkSaveSessionOnQuit->isChecked();
 }
 
 bool GeneralTab::showRootLayer()
 {
     return chkShowRootLayer->isChecked();
 }
 
 int GeneralTab::autoSaveInterval()
 {
     //convert to seconds
     return m_autosaveCheckBox->isChecked() ? m_autosaveSpinBox->value() * 60 : 0;
 }
 
 int GeneralTab::undoStackSize()
 {
     return m_undoStackSize->value();
 }
 
 bool GeneralTab::showOutlineWhilePainting()
 {
     return m_showOutlinePainting->isChecked();
 }
 
 int GeneralTab::mdiMode()
 {
     return m_cmbMDIType->currentIndex();
 }
 
 int GeneralTab::favoritePresets()
 {
     return m_favoritePresetsSpinBox->value();
 }
 
 bool GeneralTab::showCanvasMessages()
 {
     return m_chkCanvasMessages->isChecked();
 }
 
 bool GeneralTab::compressKra()
 {
     return m_chkCompressKra->isChecked();
 }
 
 bool GeneralTab::trimKra()
 {
     return m_chkTrimKra->isChecked();
 }
 
 bool GeneralTab::useZip64()
 {
     return chkZip64->isChecked();
 }
 
 bool GeneralTab::toolOptionsInDocker()
 {
     return m_radioToolOptionsInDocker->isChecked();
 }
 
 bool GeneralTab::kineticScrollingEnabled()
 {
     return m_groupBoxKineticScrollingSettings->isChecked();
 }
 
 int GeneralTab::kineticScrollingGesture()
 {
     return m_cmbKineticScrollingGesture->currentIndex();
 }
 
 int GeneralTab::kineticScrollingSensitivity()
 {
     return m_kineticScrollingSensitivitySlider->value();
 }
 
 bool GeneralTab::kineticScrollingHiddenScrollbars()
 {
     return m_chkKineticScrollingHideScrollbars->isChecked();
 }
 
 bool GeneralTab::switchSelectionCtrlAlt()
 {
     return m_chkSwitchSelectionCtrlAlt->isChecked();
 }
 
 bool GeneralTab::convertToImageColorspaceOnImport()
 {
     return m_chkConvertOnImport->isChecked();
 }
 
 bool GeneralTab::autopinLayersToTimeline()
 {
     return m_chkAutoPin->isChecked();
 }
 
 void GeneralTab::getBackgroundImage()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFile, "BackgroundImages");
     dialog.setCaption(i18n("Select a Background Image"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
     dialog.setImageFilters();
 
     QString fn = dialog.filename();
     // dialog box was canceled or somehow no file was selected
     if (fn.isEmpty()) {
         return;
     }
 
     QImage image(fn);
     if (image.isNull()) {
         QMessageBox::warning(this, i18nc("@title:window", "Krita"), i18n("%1 is not a valid image file!", fn));
     }
     else {
         m_backgroundimage->setText(fn);
     }
 }
 
 void GeneralTab::clearBackgroundImage()
 {
     // clearing the background image text will implicitly make the background color be used
     m_backgroundimage->setText("");
 }
 
 #include "kactioncollection.h"
 #include "KisActionsSnapshot.h"
 
 ShortcutSettingsTab::ShortcutSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgShortcutSettings(this);
     l->addWidget(m_page, 0, 0);
 
 
     m_snapshot.reset(new KisActionsSnapshot);
 
     KActionCollection *collection =
         KisPart::instance()->currentMainwindow()->actionCollection();
 
     Q_FOREACH (QAction *action, collection->actions()) {
         m_snapshot->addAction(action->objectName(), action);
     }
 
     QMap<QString, KActionCollection*> sortedCollections =
         m_snapshot->actionCollections();
 
     for (auto it = sortedCollections.constBegin(); it != sortedCollections.constEnd(); ++it) {
         m_page->addCollection(it.value(), it.key());
     }
 }
 
 ShortcutSettingsTab::~ShortcutSettingsTab()
 {
 }
 
 void ShortcutSettingsTab::setDefault()
 {
     m_page->allDefault();
 }
 
 void ShortcutSettingsTab::saveChanges()
 {
     m_page->save();
     KisActionRegistry::instance()->settingsPageSaved();
 }
 
 void ShortcutSettingsTab::cancelChanges()
 {
     m_page->undo();
 }
 
 ColorSettingsTab::ColorSettingsTab(QWidget *parent, const char *name)
     : QWidget(parent)
 {
     setObjectName(name);
 
     // XXX: Make sure only profiles that fit the specified color model
     // are shown in the profile combos
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgColorSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
 
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile());
     connect(m_page->chkUseSystemMonitorProfile, SIGNAL(toggled(bool)), this, SLOT(toggleAllowMonitorProfileSelection(bool)));
 
-    m_page->cmbWorkingColorSpace->setIDList(KoColorSpaceRegistry::instance()->listKeys());
-    m_page->cmbWorkingColorSpace->setCurrent(cfg.workingColorSpace());
+    QList<KoID> colorSpaces = KoColorSpaceRegistry::instance()->listKeys();
+    for (QList<KoID>::iterator id = colorSpaces.begin(); id != colorSpaces.end(); ++id) {
+        if (KoColorSpaceRegistry::instance()->colorSpaceColorModelId(id->id()) == AlphaColorModelID) {
+            colorSpaces.erase(id);
+        }
+    }
+    m_page->cmbDefColorSpace->setIDList(colorSpaces);
+    m_page->cmbDefColorSpace->setCurrent(KoColorSpaceRegistry::instance()->colorSpace(cfg.defColorModel(), cfg.defColorDepth())->id());
+
+    m_page->chkRememberLastUsedColorSpace->setChecked(cfg.rememberLastUsedColorSpace());
 
     m_page->bnAddColorProfile->setIcon(KisIconUtils::loadIcon("document-open"));
     m_page->bnAddColorProfile->setToolTip( i18n("Open Color Profile") );
     connect(m_page->bnAddColorProfile, SIGNAL(clicked()), SLOT(installProfile()));
 
     QFormLayout *monitorProfileGrid = new QFormLayout(m_page->monitorprofileholder);
     for(int i = 0; i < QGuiApplication::screens().count(); ++i) {
         QLabel *lbl = new QLabel(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileLabels << lbl;
         KisSqueezedComboBox *cmb = new KisSqueezedComboBox();
         cmb->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Fixed);
         monitorProfileGrid->addRow(lbl, cmb);
         m_monitorProfileWidgets << cmb;
     }
 
 // disable if not Linux as KisColorManager is not yet implemented outside Linux
 #ifndef Q_OS_LINUX
     m_page->chkUseSystemMonitorProfile->setChecked(false);
     m_page->chkUseSystemMonitorProfile->setDisabled(true);
     m_page->chkUseSystemMonitorProfile->setHidden(true);
 #endif
 
     refillMonitorProfiles(KoID("RGBA"));
 
     for(int i = 0; i < QApplication::screens().count(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation());
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization());
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors());
     KisImageConfig cfgImage(true);
 
     KisProofingConfigurationSP proofingConfig = cfgImage.defaultProofingconfiguration();
     m_page->sldAdaptationState->setMaximum(20);
     m_page->sldAdaptationState->setMinimum(0);
     m_page->sldAdaptationState->setValue((int)proofingConfig->adaptationState*20);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,
                                                                                       proofingConfig->proofingDepth,
                                                                                       proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
 
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
 
     m_pasteBehaviourGroup.addButton(m_page->radioPasteWeb, PASTE_ASSUME_WEB);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteMonitor, PASTE_ASSUME_MONITOR);
     m_pasteBehaviourGroup.addButton(m_page->radioPasteAsk, PASTE_ASK);
 
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour());
     Q_ASSERT(button);
 
     if (button) {
         button->setChecked(true);
     }
 
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent());
 
     toggleAllowMonitorProfileSelection(cfg.useSystemMonitorProfile());
 
 }
 
 void ColorSettingsTab::installProfile()
 {
     KoFileDialog dialog(this, KoFileDialog::OpenFiles, "OpenDocumentICC");
     dialog.setCaption(i18n("Install Color Profiles"));
     dialog.setDefaultDir(QStandardPaths::writableLocation(QStandardPaths::HomeLocation));
     dialog.setMimeTypeFilters(QStringList() << "application/vnd.iccprofile", "application/vnd.iccprofile");
     QStringList profileNames = dialog.filenames();
 
     KoColorSpaceEngine *iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
     Q_ASSERT(iccEngine);
 
     QString saveLocation = KoResourcePaths::saveLocation("icc_profiles");
 
     Q_FOREACH (const QString &profileName, profileNames) {
         if (!QFile::copy(profileName, saveLocation + QFileInfo(profileName).fileName())) {
             qWarning() << "Could not install profile!" << saveLocation + QFileInfo(profileName).fileName();
             continue;
         }
         iccEngine->addProfile(saveLocation + QFileInfo(profileName).fileName());
     }
 
     KisConfig cfg(true);
     refillMonitorProfiles(KoID("RGBA"));
 
     for(int i = 0; i < QApplication::screens().count(); ++i) {
         if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
             m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
         }
     }
 
 }
 
 void ColorSettingsTab::toggleAllowMonitorProfileSelection(bool useSystemProfile)
 {
     KisConfig cfg(true);
 
     if (useSystemProfile) {
         QStringList devices = KisColorManager::instance()->devices();
         if (devices.size() == QApplication::screens().count()) {
             for(int i = 0; i < QApplication::screens().count(); ++i) {
                 m_monitorProfileWidgets[i]->clear();
                 QString monitorForScreen = cfg.monitorForScreen(i, devices[i]);
                 Q_FOREACH (const QString &device, devices) {
                     m_monitorProfileLabels[i]->setText(i18nc("The display/screen we got from Qt", "Screen %1:", i + 1));
                     m_monitorProfileWidgets[i]->addSqueezedItem(KisColorManager::instance()->deviceName(device), device);
                     if (devices[i] == monitorForScreen) {
                         m_monitorProfileWidgets[i]->setCurrentIndex(i);
                     }
                 }
             }
         }
     }
     else {
         refillMonitorProfiles(KoID("RGBA"));
 
         for(int i = 0; i < QApplication::screens().count(); ++i) {
             if (m_monitorProfileWidgets[i]->contains(cfg.monitorProfile(i))) {
                 m_monitorProfileWidgets[i]->setCurrent(cfg.monitorProfile(i));
             }
         }
     }
 }
 
 void ColorSettingsTab::setDefault()
 {
-    m_page->cmbWorkingColorSpace->setCurrent("RGBA");
+    m_page->cmbDefColorSpace->setCurrent("RGBA");
 
     refillMonitorProfiles(KoID("RGBA"));
 
     KisConfig cfg(true);
     KisImageConfig cfgImage(true);
     KisProofingConfigurationSP proofingConfig =  cfgImage.defaultProofingconfiguration();
     const KoColorSpace *proofingSpace =  KoColorSpaceRegistry::instance()->colorSpace(proofingConfig->proofingModel,proofingConfig->proofingDepth,proofingConfig->proofingProfile);
     if (proofingSpace) {
         m_page->proofingSpaceSelector->setCurrentColorSpace(proofingSpace);
     }
     m_page->cmbProofingIntent->setCurrentIndex((int)proofingConfig->intent);
     m_page->ckbProofBlackPoint->setChecked(proofingConfig->conversionFlags.testFlag(KoColorConversionTransformation::BlackpointCompensation));
     m_page->sldAdaptationState->setValue(0);
 
     //probably this should become the screenprofile?
     KoColor ga(KoColorSpaceRegistry::instance()->rgb8());
     ga.fromKoColor(proofingConfig->warningColor);
     m_page->gamutAlarm->setColor(ga);
 
     m_page->chkBlackpoint->setChecked(cfg.useBlackPointCompensation(true));
     m_page->chkAllowLCMSOptimization->setChecked(cfg.allowLCMSOptimization(true));
     m_page->chkForcePaletteColor->setChecked(cfg.forcePaletteColors(true));
     m_page->cmbMonitorIntent->setCurrentIndex(cfg.monitorRenderIntent(true));
     m_page->chkUseSystemMonitorProfile->setChecked(cfg.useSystemMonitorProfile(true));
     QAbstractButton *button = m_pasteBehaviourGroup.button(cfg.pasteBehaviour(true));
     Q_ASSERT(button);
     if (button) {
         button->setChecked(true);
     }
 }
 
 
 void ColorSettingsTab::refillMonitorProfiles(const KoID & colorSpaceId)
 {
     for (int i = 0; i < QApplication::screens().count(); ++i) {
         m_monitorProfileWidgets[i]->clear();
     }
 
     QMap<QString, const KoColorProfile *>  profileList;
     Q_FOREACH(const KoColorProfile *profile, KoColorSpaceRegistry::instance()->profilesFor(colorSpaceId.id())) {
         profileList[profile->name()] = profile;
     }
 
     Q_FOREACH (const KoColorProfile *profile, profileList.values()) {
         //qDebug() << "Profile" << profile->name() << profile->isSuitableForDisplay() << csf->defaultProfile();
         if (profile->isSuitableForDisplay()) {
             for (int i = 0; i < QApplication::screens().count(); ++i) {
                 m_monitorProfileWidgets[i]->addSqueezedItem(profile->name());
             }
         }
     }
 
     for (int i = 0; i < QApplication::screens().count(); ++i) {
         m_monitorProfileLabels[i]->setText(i18nc("The number of the screen", "Screen %1:", i + 1));
         m_monitorProfileWidgets[i]->setCurrent(KoColorSpaceRegistry::instance()->defaultProfileForColorSpace(colorSpaceId.id()));
     }
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 void TabletSettingsTab::setDefault()
 {
     KisCubicCurve curve;
     curve.fromString(DEFAULT_CURVE_STRING);
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
         KisConfig(true).useRightMiddleTabletButtonWorkaround(true));
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         KisConfig cfg(true);
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput(true));
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput(true));
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
     }
 #else
         m_page->grpTabletApi->setVisible(false);
 #endif
 }
 
 TabletSettingsTab::TabletSettingsTab(QWidget* parent, const char* name): QWidget(parent)
 {
     setObjectName(name);
 
     QGridLayout * l = new QGridLayout(this);
     l->setMargin(0);
     m_page = new WdgTabletSettings(this);
     l->addWidget(m_page, 0, 0);
 
     KisConfig cfg(true);
     KisCubicCurve curve;
     curve.fromString( cfg.pressureTabletCurve() );
 
     m_page->pressureCurve->setMaximumSize(QSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX));
     m_page->pressureCurve->setCurve(curve);
 
     m_page->chkUseRightMiddleClickWorkaround->setChecked(
          cfg.useRightMiddleTabletButtonWorkaround());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
     // ask Qt if WinInk is actually available
     const bool isWinInkAvailable = true;
 #else
     const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
     if (isWinInkAvailable) {
         m_page->radioWintab->setChecked(!cfg.useWin8PointerInput());
         m_page->radioWin8PointerInput->setChecked(cfg.useWin8PointerInput());
     } else {
         m_page->radioWintab->setChecked(true);
         m_page->radioWin8PointerInput->setChecked(false);
         m_page->grpTabletApi->setVisible(false);
     }
 
 #ifdef USE_QT_TABLET_WINDOWS
     connect(m_page->btnResolutionSettings, SIGNAL(clicked()), SLOT(slotResolutionSettings()));
     connect(m_page->radioWintab, SIGNAL(toggled(bool)), m_page->btnResolutionSettings, SLOT(setEnabled(bool)));
     m_page->btnResolutionSettings->setEnabled(m_page->radioWintab->isChecked());
 #else
     m_page->btnResolutionSettings->setVisible(false);
 #endif
 
 #else
     m_page->grpTabletApi->setVisible(false);
 #endif
     connect(m_page->btnTabletTest, SIGNAL(clicked()), SLOT(slotTabletTest()));
 }
 
 void TabletSettingsTab::slotTabletTest()
 {
     TabletTestDialog tabletTestDialog(this);
     tabletTestDialog.exec();
 }
 
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
 #include "KisDlgCustomTabletResolution.h"
 #endif
 
 void TabletSettingsTab::slotResolutionSettings()
 {
 #if defined Q_OS_WIN && defined USE_QT_TABLET_WINDOWS
     KisDlgCustomTabletResolution dlg(this);
     dlg.exec();
 #endif
 }
 
 
 //---------------------------------------------------------------------------------------------------
 #include "kis_acyclic_signal_connector.h"
 
 int getTotalRAM()
 {
     return KisImageConfig(true).totalRAM();
 }
 
 int PerformanceTab::realTilesRAM()
 {
     return intMemoryLimit->value() - intPoolLimit->value();
 }
 
 PerformanceTab::PerformanceTab(QWidget *parent, const char *name)
     : WdgPerformanceSettings(parent, name)
 {
     KisImageConfig cfg(true);
     const double totalRAM = cfg.totalRAM();
     lblTotalMemory->setText(KFormat().formatByteSize(totalRAM * 1024 * 1024, 0, KFormat::IECBinaryDialect, KFormat::UnitMegaByte));
 
     sliderMemoryLimit->setSuffix(i18n(" %"));
     sliderMemoryLimit->setRange(1, 100, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderPoolLimit->setSuffix(i18n(" %"));
     sliderPoolLimit->setRange(0, 20, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     sliderUndoLimit->setSuffix(i18n(" %"));
     sliderUndoLimit->setRange(0, 50, 2);
     sliderMemoryLimit->setSingleStep(0.01);
 
     intMemoryLimit->setMinimumWidth(80);
     intPoolLimit->setMinimumWidth(80);
     intUndoLimit->setMinimumWidth(80);
 
 
     SliderAndSpinBoxSync *sync1 =
         new SliderAndSpinBoxSync(sliderMemoryLimit,
                                  intMemoryLimit,
                                  getTotalRAM);
 
     sync1->slotParentValueChanged();
     m_syncs << sync1;
 
     SliderAndSpinBoxSync *sync2 =
         new SliderAndSpinBoxSync(sliderPoolLimit,
                                  intPoolLimit,
                                  std::bind(&KisIntParseSpinBox::value,
                                              intMemoryLimit));
 
 
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync2, SLOT(slotParentValueChanged()));
     sync2->slotParentValueChanged();
     m_syncs << sync2;
 
     SliderAndSpinBoxSync *sync3 =
         new SliderAndSpinBoxSync(sliderUndoLimit,
                                  intUndoLimit,
                                  std::bind(&PerformanceTab::realTilesRAM,
                                              this));
 
 
     connect(intPoolLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     connect(intMemoryLimit, SIGNAL(valueChanged(int)), sync3, SLOT(slotParentValueChanged()));
     sync3->slotParentValueChanged();
     m_syncs << sync3;
 
     sliderSwapSize->setSuffix(i18n(" GiB"));
     sliderSwapSize->setRange(1, 64);
     intSwapSize->setRange(1, 64);
 
 
     KisAcyclicSignalConnector *swapSizeConnector = new KisAcyclicSignalConnector(this);
 
     swapSizeConnector->connectForwardInt(sliderSwapSize, SIGNAL(valueChanged(int)),
                                          intSwapSize, SLOT(setValue(int)));
 
     swapSizeConnector->connectBackwardInt(intSwapSize, SIGNAL(valueChanged(int)),
                                           sliderSwapSize, SLOT(setValue(int)));
 
     lblSwapFileLocation->setText(cfg.swapDir());
     connect(bnSwapFile, SIGNAL(clicked()), SLOT(selectSwapDir()));
 
     sliderThreadsLimit->setRange(1, QThread::idealThreadCount());
     sliderFrameClonesLimit->setRange(1, QThread::idealThreadCount());
     sliderFpsLimit->setRange(20, 300);
     sliderFpsLimit->setSuffix(i18n(" fps"));
 
     connect(sliderThreadsLimit, SIGNAL(valueChanged(int)), SLOT(slotThreadsLimitChanged(int)));
     connect(sliderFrameClonesLimit, SIGNAL(valueChanged(int)), SLOT(slotFrameClonesLimitChanged(int)));
 
     intCachedFramesSizeLimit->setRange(1, 10000);
     intCachedFramesSizeLimit->setSuffix(i18n(" px"));
     intCachedFramesSizeLimit->setSingleStep(1);
     intCachedFramesSizeLimit->setPageStep(1000);
 
     intRegionOfInterestMargin->setRange(1, 100);
     intRegionOfInterestMargin->setSuffix(i18n(" %"));
     intRegionOfInterestMargin->setSingleStep(1);
     intRegionOfInterestMargin->setPageStep(10);
 
     connect(chkCachedFramesSizeLimit, SIGNAL(toggled(bool)), intCachedFramesSizeLimit, SLOT(setEnabled(bool)));
     connect(chkUseRegionOfInterest, SIGNAL(toggled(bool)), intRegionOfInterestMargin, SLOT(setEnabled(bool)));
 
 #ifndef Q_OS_WIN
     // AVX workaround is needed on Windows+GCC only
     chkDisableAVXOptimizations->setVisible(false);
 #endif
 
     load(false);
 }
 
 PerformanceTab::~PerformanceTab()
 {
     qDeleteAll(m_syncs);
 }
 
 void PerformanceTab::load(bool requestDefault)
 {
     KisImageConfig cfg(true);
 
     sliderMemoryLimit->setValue(cfg.memoryHardLimitPercent(requestDefault));
     sliderPoolLimit->setValue(cfg.memoryPoolLimitPercent(requestDefault));
     sliderUndoLimit->setValue(cfg.memorySoftLimitPercent(requestDefault));
 
     chkPerformanceLogging->setChecked(cfg.enablePerfLog(requestDefault));
     chkProgressReporting->setChecked(cfg.enableProgressReporting(requestDefault));
 
     sliderSwapSize->setValue(cfg.maxSwapSize(requestDefault) / 1024);
     lblSwapFileLocation->setText(cfg.swapDir(requestDefault));
 
     m_lastUsedThreadsLimit = cfg.maxNumberOfThreads(requestDefault);
     m_lastUsedClonesLimit = cfg.frameRenderingClones(requestDefault);
 
     sliderThreadsLimit->setValue(m_lastUsedThreadsLimit);
     sliderFrameClonesLimit->setValue(m_lastUsedClonesLimit);
 
     sliderFpsLimit->setValue(cfg.fpsLimit(requestDefault));
 
     {
         KisConfig cfg2(true);
         chkOpenGLFramerateLogging->setChecked(cfg2.enableOpenGLFramerateLogging(requestDefault));
         chkBrushSpeedLogging->setChecked(cfg2.enableBrushSpeedLogging(requestDefault));
         chkDisableVectorOptimizations->setChecked(cfg2.enableAmdVectorizationWorkaround(requestDefault));
 #ifdef Q_OS_WIN
         chkDisableAVXOptimizations->setChecked(cfg2.disableAVXOptimizations(requestDefault));
 #endif
         chkBackgroundCacheGeneration->setChecked(cfg2.calculateAnimationCacheInBackground(requestDefault));
     }
 
     if (cfg.useOnDiskAnimationCacheSwapping(requestDefault)) {
         optOnDisk->setChecked(true);
     } else {
         optInMemory->setChecked(true);
     }
 
     chkCachedFramesSizeLimit->setChecked(cfg.useAnimationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setValue(cfg.animationCacheFrameSizeLimit(requestDefault));
     intCachedFramesSizeLimit->setEnabled(chkCachedFramesSizeLimit->isChecked());
 
     chkUseRegionOfInterest->setChecked(cfg.useAnimationCacheRegionOfInterest(requestDefault));
     intRegionOfInterestMargin->setValue(cfg.animationCacheRegionOfInterestMargin(requestDefault) * 100.0);
     intRegionOfInterestMargin->setEnabled(chkUseRegionOfInterest->isChecked());
 }
 
 void PerformanceTab::save()
 {
     KisImageConfig cfg(false);
 
     cfg.setMemoryHardLimitPercent(sliderMemoryLimit->value());
     cfg.setMemorySoftLimitPercent(sliderUndoLimit->value());
     cfg.setMemoryPoolLimitPercent(sliderPoolLimit->value());
 
     cfg.setEnablePerfLog(chkPerformanceLogging->isChecked());
     cfg.setEnableProgressReporting(chkProgressReporting->isChecked());
 
     cfg.setMaxSwapSize(sliderSwapSize->value() * 1024);
 
     cfg.setSwapDir(lblSwapFileLocation->text());
 
     cfg.setMaxNumberOfThreads(sliderThreadsLimit->value());
     cfg.setFrameRenderingClones(sliderFrameClonesLimit->value());
     cfg.setFpsLimit(sliderFpsLimit->value());
 
     {
         KisConfig cfg2(true);
         cfg2.setEnableOpenGLFramerateLogging(chkOpenGLFramerateLogging->isChecked());
         cfg2.setEnableBrushSpeedLogging(chkBrushSpeedLogging->isChecked());
         cfg2.setEnableAmdVectorizationWorkaround(chkDisableVectorOptimizations->isChecked());
 #ifdef Q_OS_WIN
         cfg2.setDisableAVXOptimizations(chkDisableAVXOptimizations->isChecked());
 #endif
         cfg2.setCalculateAnimationCacheInBackground(chkBackgroundCacheGeneration->isChecked());
     }
 
     cfg.setUseOnDiskAnimationCacheSwapping(optOnDisk->isChecked());
 
     cfg.setUseAnimationCacheFrameSizeLimit(chkCachedFramesSizeLimit->isChecked());
     cfg.setAnimationCacheFrameSizeLimit(intCachedFramesSizeLimit->value());
 
     cfg.setUseAnimationCacheRegionOfInterest(chkUseRegionOfInterest->isChecked());
     cfg.setAnimationCacheRegionOfInterestMargin(intRegionOfInterestMargin->value() / 100.0);
 
 }
 
 void PerformanceTab::selectSwapDir()
 {
     KisImageConfig cfg(true);
     QString swapDir = cfg.swapDir();
     swapDir = QFileDialog::getExistingDirectory(0, i18nc("@title:window", "Select a swap directory"), swapDir);
     if (swapDir.isEmpty()) {
         return;
     }
     lblSwapFileLocation->setText(swapDir);
 }
 
 void PerformanceTab::slotThreadsLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderFrameClonesLimit);
     sliderFrameClonesLimit->setValue(qMin(m_lastUsedClonesLimit, value));
     m_lastUsedThreadsLimit = value;
 }
 
 void PerformanceTab::slotFrameClonesLimitChanged(int value)
 {
     KisSignalsBlocker b(sliderThreadsLimit);
     sliderThreadsLimit->setValue(qMax(m_lastUsedThreadsLimit, value));
     m_lastUsedClonesLimit = value;
 }
 
 //---------------------------------------------------------------------------------------------------
 
 #include "KoColor.h"
 #include "opengl/KisOpenGLModeProber.h"
 #include "opengl/KisScreenInformationAdapter.h"
 #include <QOpenGLContext>
 #include <QScreen>
 
 QString colorSpaceString(KisSurfaceColorSpace cs, int depth)
 {
     const QString csString =
 #ifdef HAVE_HDR
         cs == KisSurfaceColorSpace::bt2020PQColorSpace ? "Rec. 2020 PQ" :
         cs == KisSurfaceColorSpace::scRGBColorSpace ? "Rec. 709 Linear" :
 #endif
         cs == KisSurfaceColorSpace::sRGBColorSpace ? "sRGB" :
         cs == KisSurfaceColorSpace::DefaultColorSpace ? "sRGB" :
         "Unknown Color Space";
 
     return QString("%1 (%2 bit)").arg(csString).arg(depth);
 }
 
 int formatToIndex(KisConfig::RootSurfaceFormat fmt)
 {
     return fmt == KisConfig::BT2020_PQ ? 1 :
            fmt == KisConfig::BT709_G10 ? 2 :
            0;
 }
 
 KisConfig::RootSurfaceFormat indexToFormat(int value)
 {
     return value == 1 ? KisConfig::BT2020_PQ :
            value == 2 ? KisConfig::BT709_G10 :
            KisConfig::BT709_G22;
 }
 
 DisplaySettingsTab::DisplaySettingsTab(QWidget *parent, const char *name)
     : WdgDisplaySettings(parent, name)
 {
     KisConfig cfg(true);
 
     const QString rendererOpenGLText = i18nc("canvas renderer", "OpenGL");
     const QString rendererSoftwareText = i18nc("canvas renderer", "Software Renderer (very slow)");
 #ifdef Q_OS_WIN
     const QString rendererOpenGLESText = i18nc("canvas renderer", "Direct3D 11 via ANGLE");
 #else
     const QString rendererOpenGLESText = i18nc("canvas renderer", "OpenGL ES");
 #endif
 
     const KisOpenGL::OpenGLRenderer renderer = KisOpenGL::getCurrentOpenGLRenderer();
     lblCurrentRenderer->setText(renderer == KisOpenGL::RendererOpenGLES ? rendererOpenGLESText :
                                 renderer == KisOpenGL::RendererDesktopGL ? rendererOpenGLText :
                                 renderer == KisOpenGL::RendererSoftware ? rendererSoftwareText :
                                 i18nc("canvas renderer", "Unknown"));
 
     cmbPreferredRenderer->clear();
 
     const KisOpenGL::OpenGLRenderers supportedRenderers = KisOpenGL::getSupportedOpenGLRenderers();
     const bool onlyOneRendererSupported =
         supportedRenderers == KisOpenGL::RendererDesktopGL ||
         supportedRenderers == KisOpenGL::RendererOpenGLES ||
         supportedRenderers == KisOpenGL::RendererSoftware;
 
 
     if (!onlyOneRendererSupported) {
         QString qtPreferredRendererText;
         if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererOpenGLES) {
             qtPreferredRendererText = rendererOpenGLESText;
         } else if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererSoftware) {
             qtPreferredRendererText = rendererSoftwareText;
         } else {
             qtPreferredRendererText = rendererOpenGLText;
         }
         cmbPreferredRenderer->addItem(i18nc("canvas renderer", "Auto (%1)", qtPreferredRendererText), KisOpenGL::RendererAuto);
         cmbPreferredRenderer->setCurrentIndex(0);
     } else {
         cmbPreferredRenderer->setEnabled(false);
     }
 
     if (supportedRenderers & KisOpenGL::RendererDesktopGL) {
         cmbPreferredRenderer->addItem(rendererOpenGLText, KisOpenGL::RendererDesktopGL);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererDesktopGL) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
 
 #ifdef Q_OS_ANDROID
     if (onlyOneRendererSupported) {
         if (KisOpenGL::getQtPreferredOpenGLRenderer() == KisOpenGL::RendererOpenGLES) {
             cmbPreferredRenderer->addItem(rendererOpenGLESText, KisOpenGL::RendererOpenGLES);
             cmbPreferredRenderer->setCurrentIndex(0);
         }
     }
 #endif
 
 #ifdef Q_OS_WIN
     if (supportedRenderers & KisOpenGL::RendererOpenGLES) {
         cmbPreferredRenderer->addItem(rendererOpenGLESText, KisOpenGL::RendererOpenGLES);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererOpenGLES) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
     if (supportedRenderers & KisOpenGL::RendererSoftware) {
         cmbPreferredRenderer->addItem(rendererSoftwareText, KisOpenGL::RendererSoftware);
         if (KisOpenGL::getUserPreferredOpenGLRendererConfig() == KisOpenGL::RendererSoftware) {
             cmbPreferredRenderer->setCurrentIndex(cmbPreferredRenderer->count() - 1);
         }
     }
 #endif
 
     if (!(supportedRenderers &
           (KisOpenGL::RendererDesktopGL |
            KisOpenGL::RendererOpenGLES |
            KisOpenGL::RendererSoftware))) {
 
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     } else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL());
         chkUseTextureBuffer->setEnabled(cfg.useOpenGL());
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer());
         chkDisableVsync->setVisible(cfg.showAdvancedOpenGLSettings());
         chkDisableVsync->setEnabled(cfg.useOpenGL());
         chkDisableVsync->setChecked(cfg.disableVSync());
         cmbFilterMode->setEnabled(cfg.useOpenGL());
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode());
         // Don't show the high quality filtering mode if it's not available
         if (!KisOpenGL::supportsLoD()) {
             cmbFilterMode->removeItem(3);
         }
     }
 
     lblCurrentDisplayFormat->setText("");
     lblCurrentRootSurfaceFormat->setText("");
     lblHDRWarning->setText("");
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::sRGBColorSpace, 8));
 #ifdef HAVE_HDR
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::bt2020PQColorSpace, 10));
     cmbPreferedRootSurfaceFormat->addItem(colorSpaceString(KisSurfaceColorSpace::scRGBColorSpace, 16));
 #endif
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
 
     if (!context) {
         context = QOpenGLContext::globalShareContext();
     }
 
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (screen && adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 QStringList toolTip;
 
                 toolTip << i18n("Display Id: %1", info.screen->name());
                 toolTip << i18n("Display Name: %1 %2", info.screen->manufacturer(), info.screen->model());
                 toolTip << i18n("Min Luminance: %1", info.minLuminance);
                 toolTip << i18n("Max Luminance: %1", info.maxLuminance);
                 toolTip << i18n("Max Full Frame Luminance: %1", info.maxFullFrameLuminance);
                 toolTip << i18n("Red Primary: %1, %2", info.redPrimary[0], info.redPrimary[1]);
                 toolTip << i18n("Green Primary: %1, %2", info.greenPrimary[0], info.greenPrimary[1]);
                 toolTip << i18n("Blue Primary: %1, %2", info.bluePrimary[0], info.bluePrimary[1]);
                 toolTip << i18n("White Point: %1, %2", info.whitePoint[0], info.whitePoint[1]);
 
                 lblCurrentDisplayFormat->setToolTip(toolTip.join('\n'));
                 lblCurrentDisplayFormat->setText(colorSpaceString(info.colorSpace, info.bitsPerColor));
             } else {
                 lblCurrentDisplayFormat->setToolTip("");
                 lblCurrentDisplayFormat->setText(i18n("Unknown"));
             }
         } else {
             lblCurrentDisplayFormat->setToolTip("");
             lblCurrentDisplayFormat->setText(i18n("Unknown"));
             qWarning() << "Failed to fetch display info:" << adapter.errorString();
         }
 
         const QSurfaceFormat currentFormat = KisOpenGLModeProber::instance()->surfaceformatInUse();
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         KisSurfaceColorSpace colorSpace = currentFormat.colorSpace();
 #else
         KisSurfaceColorSpace colorSpace = KisSurfaceColorSpace::DefaultColorSpace;
 #endif
         lblCurrentRootSurfaceFormat->setText(colorSpaceString(colorSpace, currentFormat.redBufferSize()));
         cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(cfg.rootSurfaceFormat()));
         connect(cmbPreferedRootSurfaceFormat, SIGNAL(currentIndexChanged(int)), SLOT(slotPreferredSurfaceFormatChanged(int)));
         slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
     }
 
 #ifndef HAVE_HDR
     grpHDRSettings->setVisible(false);
     tabWidget->removeTab(tabWidget->indexOf(tabHDR));
 #endif
 
     const QStringList openglWarnings = KisOpenGL::getOpenGLWarnings();
     if (openglWarnings.isEmpty()) {
         lblOpenGLWarnings->setVisible(false);
     } else {
         QString text("<span style=\"color: yellow;\">&#x26A0;</span> ");
         text.append(i18n("Warning(s):"));
         text.append("<ul>");
         Q_FOREACH (const QString &warning, openglWarnings) {
             text.append("<li>");
             text.append(warning.toHtmlEscaped());
             text.append("</li>");
         }
         text.append("</ul>");
         lblOpenGLWarnings->setText(text);
         lblOpenGLWarnings->setVisible(true);
     }
 
     if (qApp->applicationName() == "kritasketch" || qApp->applicationName() == "kritagemini") {
        grpOpenGL->setVisible(false);
        grpOpenGL->setMaximumHeight(0);
     }
 
     KisImageConfig imageCfg(false);
 
     KoColor c;
     c.fromQColor(imageCfg.selectionOverlayMaskColor());
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setRange(0.0, 1.0, 2);
     sldSelectionOverlayOpacity->setSingleStep(0.05);
     sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor().alphaF());
 
     intCheckSize->setValue(cfg.checkSize());
     chkMoving->setChecked(cfg.scrollCheckers());
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1());
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2());
     colorChecks2->setColor(ck2);
     KoColor cb(KoColorSpaceRegistry::instance()->rgb8());
     cb.fromQColor(cfg.canvasBorderColor());
     canvasBorder->setColor(cb);
     hideScrollbars->setChecked(cfg.hideScrollbars());
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves());
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline());
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor());
     chkHidePopups->setChecked(cfg.hidePopups());
 
     connect(grpOpenGL, SIGNAL(toggled(bool)), SLOT(slotUseOpenGLToggled(bool)));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor());
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold() * 100);
 }
 
 void DisplaySettingsTab::setDefault()
 {
     KisConfig cfg(true);
     cmbPreferredRenderer->setCurrentIndex(0);
     if (!(KisOpenGL::getSupportedOpenGLRenderers() &
             (KisOpenGL::RendererDesktopGL | KisOpenGL::RendererOpenGLES))) {
         grpOpenGL->setEnabled(false);
         grpOpenGL->setChecked(false);
         chkUseTextureBuffer->setEnabled(false);
         chkDisableVsync->setEnabled(false);
         cmbFilterMode->setEnabled(false);
     }
     else {
         grpOpenGL->setEnabled(true);
         grpOpenGL->setChecked(cfg.useOpenGL(true));
         chkUseTextureBuffer->setChecked(cfg.useOpenGLTextureBuffer(true));
         chkUseTextureBuffer->setEnabled(true);
         chkDisableVsync->setEnabled(true);
         chkDisableVsync->setChecked(cfg.disableVSync(true));
         cmbFilterMode->setEnabled(true);
         cmbFilterMode->setCurrentIndex(cfg.openGLFilteringMode(true));
     }
 
     chkMoving->setChecked(cfg.scrollCheckers(true));
 
     KisImageConfig imageCfg(false);
     KoColor c;
     c.fromQColor(imageCfg.selectionOverlayMaskColor(true));
     c.setOpacity(1.0);
     btnSelectionOverlayColor->setColor(c);
     sldSelectionOverlayOpacity->setValue(imageCfg.selectionOverlayMaskColor(true).alphaF());
 
     intCheckSize->setValue(cfg.checkSize(true));
     KoColor ck1(KoColorSpaceRegistry::instance()->rgb8());
     ck1.fromQColor(cfg.checkersColor1(true));
     colorChecks1->setColor(ck1);
     KoColor ck2(KoColorSpaceRegistry::instance()->rgb8());
     ck2.fromQColor(cfg.checkersColor2(true));
     colorChecks2->setColor(ck2);
     KoColor cvb(KoColorSpaceRegistry::instance()->rgb8());
     cvb.fromQColor(cfg.canvasBorderColor(true));
     canvasBorder->setColor(cvb);
     hideScrollbars->setChecked(cfg.hideScrollbars(true));
     chkCurveAntialiasing->setChecked(cfg.antialiasCurves(true));
     chkSelectionOutlineAntialiasing->setChecked(cfg.antialiasSelectionOutline(true));
     chkChannelsAsColor->setChecked(cfg.showSingleChannelAsColor(true));
     chkHidePopups->setChecked(cfg.hidePopups(true));
 
     KoColor gridColor(KoColorSpaceRegistry::instance()->rgb8());
     gridColor.fromQColor(cfg.getPixelGridColor(true));
     pixelGridColorButton->setColor(gridColor);
     pixelGridDrawingThresholdBox->setValue(cfg.getPixelGridDrawingThreshold(true) * 100);
 
     cmbPreferedRootSurfaceFormat->setCurrentIndex(formatToIndex(KisConfig::BT709_G22));
     slotPreferredSurfaceFormatChanged(cmbPreferedRootSurfaceFormat->currentIndex());
 }
 
 void DisplaySettingsTab::slotUseOpenGLToggled(bool isChecked)
 {
     chkUseTextureBuffer->setEnabled(isChecked);
     chkDisableVsync->setEnabled(isChecked);
     cmbFilterMode->setEnabled(isChecked);
 }
 
 void DisplaySettingsTab::slotPreferredSurfaceFormatChanged(int index)
 {
     Q_UNUSED(index);
 
     QOpenGLContext *context = QOpenGLContext::currentContext();
     if (context) {
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
         QScreen *screen = QGuiApplication::screenAt(rect().center());
 #else
         QScreen *screen = 0;
 #endif
         KisScreenInformationAdapter adapter(context);
         if (adapter.isValid()) {
             KisScreenInformationAdapter::ScreenInfo info = adapter.infoForScreen(screen);
             if (info.isValid()) {
                 if (cmbPreferedRootSurfaceFormat->currentIndex() != formatToIndex(KisConfig::BT709_G22) &&
                     info.colorSpace == KisSurfaceColorSpace::sRGBColorSpace) {
                     lblHDRWarning->setText(i18n("WARNING: current display doesn't support HDR rendering"));
                 } else {
                     lblHDRWarning->setText("");
                 }
             }
         }
     }
 }
 
 //---------------------------------------------------------------------------------------------------
 FullscreenSettingsTab::FullscreenSettingsTab(QWidget* parent) : WdgFullscreenSettingsBase(parent)
 {
     KisConfig cfg(true);
 
     chkDockers->setChecked(cfg.hideDockersFullscreen());
     chkMenu->setChecked(cfg.hideMenuFullscreen());
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen());
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen());
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen());
     chkToolbar->setChecked(cfg.hideToolbarFullscreen());
 
 }
 
 void FullscreenSettingsTab::setDefault()
 {
     KisConfig cfg(true);
     chkDockers->setChecked(cfg.hideDockersFullscreen(true));
     chkMenu->setChecked(cfg.hideMenuFullscreen(true));
     chkScrollbars->setChecked(cfg.hideScrollbarsFullscreen(true));
     chkStatusbar->setChecked(cfg.hideStatusbarFullscreen(true));
     chkTitlebar->setChecked(cfg.hideTitlebarFullscreen(true));
     chkToolbar->setChecked(cfg.hideToolbarFullscreen(true));
 }
 
 
 //---------------------------------------------------------------------------------------------------
 
 KisDlgPreferences::KisDlgPreferences(QWidget* parent, const char* name)
     : KPageDialog(parent)
 {
     Q_UNUSED(name);
     setWindowTitle(i18n("Configure Krita"));
     setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::RestoreDefaults);
 
     setFaceType(KPageDialog::List);
 
     // General
     KoVBox *vbox = new KoVBox();
     KPageWidgetItem *page = new KPageWidgetItem(vbox, i18n("General"));
     page->setObjectName("general");
     page->setHeader(i18n("General"));
     page->setIcon(KisIconUtils::loadIcon("go-home"));
     m_pages << page;
     addPage(page);
     m_general = new GeneralTab(vbox);
 
     // Shortcuts
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Keyboard Shortcuts"));
     page->setObjectName("shortcuts");
     page->setHeader(i18n("Shortcuts"));
     page->setIcon(KisIconUtils::loadIcon("document-export"));
     m_pages << page;
     addPage(page);
     m_shortcutSettings = new ShortcutSettingsTab(vbox);
     connect(this, SIGNAL(accepted()), m_shortcutSettings, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_shortcutSettings, SLOT(cancelChanges()));
 
     // Canvas input settings
     m_inputConfiguration = new KisInputConfigurationPage();
     page = addPage(m_inputConfiguration, i18n("Canvas Input Settings"));
     page->setHeader(i18n("Canvas Input"));
     page->setObjectName("canvasinput");
     page->setIcon(KisIconUtils::loadIcon("configure"));
     m_pages << page;
 
     // Display
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Display"));
     page->setObjectName("display");
     page->setHeader(i18n("Display"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-display"));
     m_pages << page;
     addPage(page);
     m_displaySettings = new DisplaySettingsTab(vbox);
 
     // Color
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Color Management"));
     page->setObjectName("colormanagement");
     page->setHeader(i18n("Color"));
     page->setIcon(KisIconUtils::loadIcon("preferences-desktop-color"));
     m_pages << page;
     addPage(page);
     m_colorSettings = new ColorSettingsTab(vbox);
 
     // Performance
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Performance"));
     page->setObjectName("performance");
     page->setHeader(i18n("Performance"));
     page->setIcon(KisIconUtils::loadIcon("applications-system"));
     m_pages << page;
     addPage(page);
     m_performanceSettings = new PerformanceTab(vbox);
 
     // Tablet
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Tablet settings"));
     page->setObjectName("tablet");
     page->setHeader(i18n("Tablet"));
     page->setIcon(KisIconUtils::loadIcon("document-edit"));
     m_pages << page;
     addPage(page);
     m_tabletSettings = new TabletSettingsTab(vbox);
 
     // full-screen mode
     vbox = new KoVBox();
     page = new KPageWidgetItem(vbox, i18n("Canvas-only settings"));
     page->setObjectName("canvasonly");
     page->setHeader(i18n("Canvas-only"));
     page->setIcon(KisIconUtils::loadIcon("folder-pictures"));
     m_pages << page;
     addPage(page);
     m_fullscreenSettings = new FullscreenSettingsTab(vbox);
 
     // Author profiles
     m_authorPage = new KoConfigAuthorPage();
     page = addPage(m_authorPage, i18nc("@title:tab Author page", "Author" ));
     page->setObjectName("author");
     page->setHeader(i18n("Author"));
     page->setIcon(KisIconUtils::loadIcon("im-user"));
     m_pages << page;
 
     QPushButton *restoreDefaultsButton = button(QDialogButtonBox::RestoreDefaults);
     restoreDefaultsButton->setText(i18nc("@action:button", "Restore Defaults"));
 
     connect(this, SIGNAL(accepted()), m_inputConfiguration, SLOT(saveChanges()));
     connect(this, SIGNAL(rejected()), m_inputConfiguration, SLOT(revertChanges()));
 
     KisPreferenceSetRegistry *preferenceSetRegistry = KisPreferenceSetRegistry::instance();
     QStringList keys = preferenceSetRegistry->keys();
     keys.sort();
     Q_FOREACH(const QString &key, keys) {
         KisAbstractPreferenceSetFactory *preferenceSetFactory = preferenceSetRegistry->value(key);
         KisPreferenceSet* preferenceSet = preferenceSetFactory->createPreferenceSet();
         vbox = new KoVBox();
         page = new KPageWidgetItem(vbox, preferenceSet->name());
         page->setHeader(preferenceSet->header());
         page->setIcon(preferenceSet->icon());
         addPage(page);
         preferenceSet->setParent(vbox);
         preferenceSet->loadPreferences();
 
         connect(restoreDefaultsButton, SIGNAL(clicked(bool)), preferenceSet, SLOT(loadDefaultPreferences()), Qt::UniqueConnection);
         connect(this, SIGNAL(accepted()), preferenceSet, SLOT(savePreferences()), Qt::UniqueConnection);
     }
 
     connect(restoreDefaultsButton, SIGNAL(clicked(bool)), this, SLOT(slotDefault()));
 
     KisConfig cfg(true);
     QString currentPageName = cfg.readEntry<QString>("KisDlgPreferences/CurrentPage");
     Q_FOREACH(KPageWidgetItem *page, m_pages) {
         if (page->objectName() == currentPageName) {
             setCurrentPage(page);
             break;
         }
     }
 }
 
 KisDlgPreferences::~KisDlgPreferences()
 {
     KisConfig cfg(true);
     cfg.writeEntry<QString>("KisDlgPreferences/CurrentPage", currentPage()->objectName());
 }
 
 void KisDlgPreferences::showEvent(QShowEvent *event){
     KPageDialog::showEvent(event);
     button(QDialogButtonBox::Cancel)->setAutoDefault(false);
     button(QDialogButtonBox::Ok)->setAutoDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setAutoDefault(false);
     button(QDialogButtonBox::Cancel)->setDefault(false);
     button(QDialogButtonBox::Ok)->setDefault(false);
     button(QDialogButtonBox::RestoreDefaults)->setDefault(false);
 }
 
 void KisDlgPreferences::slotButtonClicked(QAbstractButton *button)
 {
     if (buttonBox()->buttonRole(button) == QDialogButtonBox::RejectRole) {
         m_cancelClicked = true;
     }
 }
 
 void KisDlgPreferences::slotDefault()
 {
     if (currentPage()->objectName() == "general") {
         m_general->setDefault();
     }
     else if (currentPage()->objectName() == "shortcuts") {
         m_shortcutSettings->setDefault();
     }
     else if (currentPage()->objectName() == "display") {
         m_displaySettings->setDefault();
     }
     else if (currentPage()->objectName() == "colormanagement") {
         m_colorSettings->setDefault();
     }
     else if (currentPage()->objectName() == "performance") {
         m_performanceSettings->load(true);
     }
     else if (currentPage()->objectName() == "tablet") {
         m_tabletSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasonly") {
         m_fullscreenSettings->setDefault();
     }
     else if (currentPage()->objectName() == "canvasinput") {
         m_inputConfiguration->setDefaults();
     }
 }
 
 bool KisDlgPreferences::editPreferences()
 {
     connect(this->buttonBox(), SIGNAL(clicked(QAbstractButton*)), this, SLOT(slotButtonClicked(QAbstractButton*)));
 
     int retval = exec();
     Q_UNUSED(retval)
 
     if (!m_cancelClicked) {
         // General settings
         KisConfig cfg(false);
         cfg.setNewCursorStyle(m_general->cursorStyle());
         cfg.setNewOutlineStyle(m_general->outlineStyle());
         cfg.setShowRootLayer(m_general->showRootLayer());
         cfg.setShowOutlineWhilePainting(m_general->showOutlineWhilePainting());
         cfg.setForceAlwaysFullSizedOutline(!m_general->m_changeBrushOutline->isChecked());
         cfg.setSessionOnStartup(m_general->sessionOnStartup());
         cfg.setSaveSessionOnQuit(m_general->saveSessionOnQuit());
 
         KConfigGroup group = KSharedConfig::openConfig()->group("File Dialogs");
         group.writeEntry("DontUseNativeFileDialog", !m_general->m_chkNativeFileDialog->isChecked());
 
         cfg.writeEntry<int>("maximumBrushSize", m_general->intMaxBrushSize->value());
 
         cfg.writeEntry<int>("mdi_viewmode", m_general->mdiMode());
         cfg.setMDIBackgroundColor(m_general->m_mdiColor->color().toXML());
         cfg.setMDIBackgroundImage(m_general->m_backgroundimage->text());
         cfg.setAutoSaveInterval(m_general->autoSaveInterval());
         cfg.writeEntry("autosavefileshidden", m_general->chkHideAutosaveFiles->isChecked());
 
         cfg.setBackupFile(m_general->m_backupFileCheckBox->isChecked());
         cfg.writeEntry("backupfilelocation", m_general->cmbBackupFileLocation->currentIndex());
         cfg.writeEntry("backupfilesuffix", m_general->txtBackupFileSuffix->text());
         cfg.writeEntry("numberofbackupfiles", m_general->intNumBackupFiles->value());
 
 
         cfg.setShowCanvasMessages(m_general->showCanvasMessages());
         cfg.setCompressKra(m_general->compressKra());
         cfg.setTrimKra(m_general->trimKra());
         cfg.setUseZip64(m_general->useZip64());
 
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("EnableHiDPI", m_general->m_chkHiDPI->isChecked());
 #ifdef HAVE_HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY
         kritarc.setValue("EnableHiDPIFractionalScaling", m_general->m_chkHiDPIFractionalScaling->isChecked());
 #endif
         kritarc.setValue("LogUsage", m_general->chkUsageLogging->isChecked());
 
         cfg.setToolOptionsInDocker(m_general->toolOptionsInDocker());
 
         cfg.writeEntry<bool>("useCreamyAlphaDarken", (bool)!m_general->cmbFlowMode->currentIndex());
 
         cfg.setKineticScrollingEnabled(m_general->kineticScrollingEnabled());
         cfg.setKineticScrollingGesture(m_general->kineticScrollingGesture());
         cfg.setKineticScrollingSensitivity(m_general->kineticScrollingSensitivity());
         cfg.setKineticScrollingHideScrollbars(m_general->kineticScrollingHiddenScrollbars());
 
         cfg.setSwitchSelectionCtrlAlt(m_general->switchSelectionCtrlAlt());
         cfg.setDisableTouchOnCanvas(!m_general->chkEnableTouch->isChecked());
         cfg.setDisableTouchRotation(!m_general->chkEnableTouchRotation->isChecked());
         cfg.setActivateTransformToolAfterPaste(m_general->chkEnableTranformToolAfterPaste->isChecked());
         cfg.setConvertToImageColorspaceOnImport(m_general->convertToImageColorspaceOnImport());
         cfg.setUndoStackLimit(m_general->undoStackSize());
         cfg.setFavoritePresets(m_general->favoritePresets());
 
         cfg.setAutoPinLayersToTimeline(m_general->autopinLayersToTimeline());
 
         cfg.writeEntry(KisResourceCacheDb::dbLocationKey, m_general->m_urlCacheDbLocation->fileName());
         cfg.writeEntry(KisResourceLocator::resourceLocationKey, m_general->m_urlResourceFolder->fileName());
 
         // Color settings
         cfg.setUseSystemMonitorProfile(m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
         for (int i = 0; i < QApplication::screens().count(); ++i) {
             if (m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked()) {
                 int currentIndex = m_colorSettings->m_monitorProfileWidgets[i]->currentIndex();
                 QString monitorid = m_colorSettings->m_monitorProfileWidgets[i]->itemData(currentIndex).toString();
                 cfg.setMonitorForScreen(i, monitorid);
             }
             else {
                 cfg.setMonitorProfile(i,
                                       m_colorSettings->m_monitorProfileWidgets[i]->currentUnsqueezedText(),
                                       m_colorSettings->m_page->chkUseSystemMonitorProfile->isChecked());
             }
         }
-        cfg.setWorkingColorSpace(m_colorSettings->m_page->cmbWorkingColorSpace->currentItem().id());
+        const QString defaultColorSpace = m_colorSettings->m_page->cmbDefColorSpace->currentItem().id();
+        cfg.defColorModel(KoColorSpaceRegistry::instance()->colorSpaceColorModelId(defaultColorSpace).id());
+        cfg.defColorDepth(KoColorSpaceRegistry::instance()->colorSpaceColorDepthId(defaultColorSpace).id());
+
+        cfg.setRememberLastUsedColorSpace(m_colorSettings->m_page->chkRememberLastUsedColorSpace->isChecked());
 
         KisImageConfig cfgImage(false);
         cfgImage.setDefaultProofingConfig(m_colorSettings->m_page->proofingSpaceSelector->currentColorSpace(),
                                           m_colorSettings->m_page->cmbProofingIntent->currentIndex(),
                                           m_colorSettings->m_page->ckbProofBlackPoint->isChecked(),
                                           m_colorSettings->m_page->gamutAlarm->color(),
                                           (double)m_colorSettings->m_page->sldAdaptationState->value()/20);
         cfg.setUseBlackPointCompensation(m_colorSettings->m_page->chkBlackpoint->isChecked());
         cfg.setAllowLCMSOptimization(m_colorSettings->m_page->chkAllowLCMSOptimization->isChecked());
         cfg.setForcePaletteColors(m_colorSettings->m_page->chkForcePaletteColor->isChecked());
         cfg.setPasteBehaviour(m_colorSettings->m_pasteBehaviourGroup.checkedId());
         cfg.setRenderIntent(m_colorSettings->m_page->cmbMonitorIntent->currentIndex());
 
         // Tablet settings
         cfg.setPressureTabletCurve( m_tabletSettings->m_page->pressureCurve->curve().toString() );
         cfg.setUseRightMiddleTabletButtonWorkaround(
             m_tabletSettings->m_page->chkUseRightMiddleClickWorkaround->isChecked());
 
 #if defined Q_OS_WIN && (!defined USE_QT_TABLET_WINDOWS || defined QT_HAS_WINTAB_SWITCH)
 #ifdef USE_QT_TABLET_WINDOWS
         // ask Qt if WinInk is actually available
         const bool isWinInkAvailable = true;
 #else
         const bool isWinInkAvailable = KisTabletSupportWin8::isAvailable();
 #endif
         if (isWinInkAvailable) {
             cfg.setUseWin8PointerInput(m_tabletSettings->m_page->radioWin8PointerInput->isChecked());
         }
 #endif
 
         m_performanceSettings->save();
 
         if (!cfg.useOpenGL() && m_displaySettings->grpOpenGL->isChecked())
             cfg.setCanvasState("TRY_OPENGL");
 
         if (m_displaySettings->grpOpenGL->isChecked()) {
             KisOpenGL::OpenGLRenderer renderer = static_cast<KisOpenGL::OpenGLRenderer>(
                     m_displaySettings->cmbPreferredRenderer->itemData(
                             m_displaySettings->cmbPreferredRenderer->currentIndex()).toInt());
             KisOpenGL::setUserPreferredOpenGLRendererConfig(renderer);
         } else {
             KisOpenGL::setUserPreferredOpenGLRendererConfig(KisOpenGL::RendererNone);
         }
 
         cfg.setUseOpenGLTextureBuffer(m_displaySettings->chkUseTextureBuffer->isChecked());
         cfg.setOpenGLFilteringMode(m_displaySettings->cmbFilterMode->currentIndex());
         cfg.setDisableVSync(m_displaySettings->chkDisableVsync->isChecked());
         cfg.setRootSurfaceFormat(&kritarc, indexToFormat(m_displaySettings->cmbPreferedRootSurfaceFormat->currentIndex()));
 
         cfg.setCheckSize(m_displaySettings->intCheckSize->value());
         cfg.setScrollingCheckers(m_displaySettings->chkMoving->isChecked());
         cfg.setCheckersColor1(m_displaySettings->colorChecks1->color().toQColor());
         cfg.setCheckersColor2(m_displaySettings->colorChecks2->color().toQColor());
         cfg.setCanvasBorderColor(m_displaySettings->canvasBorder->color().toQColor());
         cfg.setHideScrollbars(m_displaySettings->hideScrollbars->isChecked());
         KoColor c = m_displaySettings->btnSelectionOverlayColor->color();
         c.setOpacity(m_displaySettings->sldSelectionOverlayOpacity->value());
         cfgImage.setSelectionOverlayMaskColor(c.toQColor());
         cfg.setAntialiasCurves(m_displaySettings->chkCurveAntialiasing->isChecked());
         cfg.setAntialiasSelectionOutline(m_displaySettings->chkSelectionOutlineAntialiasing->isChecked());
         cfg.setShowSingleChannelAsColor(m_displaySettings->chkChannelsAsColor->isChecked());
         cfg.setHidePopups(m_displaySettings->chkHidePopups->isChecked());
 
         cfg.setHideDockersFullscreen(m_fullscreenSettings->chkDockers->checkState());
         cfg.setHideMenuFullscreen(m_fullscreenSettings->chkMenu->checkState());
         cfg.setHideScrollbarsFullscreen(m_fullscreenSettings->chkScrollbars->checkState());
         cfg.setHideStatusbarFullscreen(m_fullscreenSettings->chkStatusbar->checkState());
         cfg.setHideTitlebarFullscreen(m_fullscreenSettings->chkTitlebar->checkState());
         cfg.setHideToolbarFullscreen(m_fullscreenSettings->chkToolbar->checkState());
 
         cfg.setCursorMainColor(m_general->cursorColorBtutton->color().toQColor());
         cfg.setPixelGridColor(m_displaySettings->pixelGridColorButton->color().toQColor());
         cfg.setPixelGridDrawingThreshold(m_displaySettings->pixelGridDrawingThresholdBox->value() / 100);
 
         m_authorPage->apply();
 
         cfg.logImportantSettings();
 
     }
 
     return !m_cancelClicked;
 }
 
diff --git a/libs/ui/forms/wdgcolorsettings.ui b/libs/ui/forms/wdgcolorsettings.ui
index 3a619b76b7..8019005e8d 100644
--- a/libs/ui/forms/wdgcolorsettings.ui
+++ b/libs/ui/forms/wdgcolorsettings.ui
@@ -1,430 +1,440 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>WdgColorSettings</class>
  <widget class="QWidget" name="WdgColorSettings">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>568</width>
     <height>335</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string>Color Settings</string>
   </property>
   <layout class="QGridLayout" name="gridLayout">
    <item row="0" column="0">
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="tab">
       <attribute name="title">
        <string>General</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout">
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="textLabel1_2">
            <property name="text">
-            <string>Default color model for new images:</string>
+            <string>Default color space for new images:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item>
-          <widget class="KisCmbIDList" name="cmbWorkingColorSpace">
+          <widget class="KisCmbIDList" name="cmbDefColorSpace">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <property name="minimumSize">
             <size>
              <width>0</width>
              <height>20</height>
             </size>
            </property>
           </widget>
          </item>
         </layout>
        </item>
+       <item>
+        <widget class="QCheckBox" name="chkRememberLastUsedColorSpace">
+         <property name="text">
+          <string>Remember last used color space</string>
+         </property>
+         <property name="checked">
+          <bool>false</bool>
+         </property>
+        </widget>
+       </item>
        <item>
         <widget class="QGroupBox" name="grpPasteBehaviour">
          <property name="title">
           <string>When Pasting Into Krita From Other Applications</string>
          </property>
          <layout class="QVBoxLayout">
           <item>
            <widget class="QRadioButton" name="radioPasteWeb">
             <property name="text">
              <string>Assume sRGB (like images from the web are supposed to be seen)</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="radioPasteMonitor">
             <property name="text">
              <string>Assume &amp;monitor profile (like you see it in other applications)</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QRadioButton" name="radioPasteAsk">
             <property name="text">
              <string>As&amp;k each time</string>
             </property>
            </widget>
           </item>
           <item>
            <widget class="QLabel" name="textLabel1_2_2">
             <property name="text">
              <string>Note: When copying/pasting inside Krita color info is always preserved.</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkBlackpoint">
          <property name="text">
           <string>Use Blackpoint Compensation</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkAllowLCMSOptimization">
          <property name="text">
           <string>Allow Little CMS optimizations (uncheck when using linear light RGB or XYZ)</string>
          </property>
          <property name="checked">
           <bool>true</bool>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QCheckBox" name="chkForcePaletteColor">
          <property name="text">
           <string>Enforce palette colors: always select the nearest color from the active palette.</string>
          </property>
         </widget>
        </item>
        <item>
         <spacer name="verticalSpacer_3">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_2">
       <attribute name="title">
        <string>Display</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
         <widget class="QCheckBox" name="chkUseSystemMonitorProfile">
          <property name="text">
           <string>Use system monitor profile</string>
          </property>
          <property name="checked">
           <bool>false</bool>
          </property>
         </widget>
        </item>
        <item>
         <widget class="QWidget" name="monitorprofileholder" native="true">
          <property name="minimumSize">
           <size>
            <width>50</width>
            <height>50</height>
           </size>
          </property>
         </widget>
        </item>
        <item>
         <layout class="QHBoxLayout">
          <property name="leftMargin">
           <number>0</number>
          </property>
          <property name="topMargin">
           <number>0</number>
          </property>
          <property name="rightMargin">
           <number>0</number>
          </property>
          <property name="bottomMargin">
           <number>0</number>
          </property>
          <item>
           <widget class="QLabel" name="lblRenderingIntent">
            <property name="toolTip">
             <string>The icm profile for your calibrated monitor</string>
            </property>
            <property name="text">
             <string>&amp;Rendering intent:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
            <property name="buddy">
             <cstring>cmbMonitorIntent</cstring>
            </property>
           </widget>
          </item>
          <item>
           <widget class="KComboBox" name="cmbMonitorIntent">
            <property name="sizePolicy">
             <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
              <horstretch>0</horstretch>
              <verstretch>0</verstretch>
             </sizepolicy>
            </property>
            <item>
             <property name="text">
              <string>Perceptual</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Relative Colorimetric</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Saturation</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Absolute Colorimetric</string>
             </property>
            </item>
           </widget>
          </item>
         </layout>
        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout_2">
          <item>
           <widget class="QLabel" name="label_2">
            <property name="text">
             <string>Add new color profile:</string>
            </property>
           </widget>
          </item>
          <item>
           <widget class="QPushButton" name="bnAddColorProfile">
            <property name="maximumSize">
             <size>
              <width>24</width>
              <height>24</height>
             </size>
            </property>
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item>
           <spacer name="horizontalSpacer">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
            <property name="sizeHint" stdset="0">
             <size>
              <width>40</width>
              <height>20</height>
             </size>
            </property>
           </spacer>
          </item>
         </layout>
        </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="tab_3">
       <attribute name="title">
        <string>Soft Proofing</string>
       </attribute>
       <layout class="QGridLayout" name="gridLayout_3">
        <item row="2" column="0">
         <layout class="QGridLayout" name="gridLayout_2">
          <item row="0" column="1">
           <widget class="QComboBox" name="cmbProofingIntent">
            <item>
             <property name="text">
              <string>Perceptual</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Relative Colorimetric</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Saturation</string>
             </property>
            </item>
            <item>
             <property name="text">
              <string>Absolute Colorimetric</string>
             </property>
            </item>
           </widget>
          </item>
          <item row="1" column="0">
           <widget class="QLabel" name="lblAdaptationState">
            <property name="text">
             <string>Adaptation State:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="0" column="0">
           <widget class="QLabel" name="lblProofingIntent">
            <property name="text">
             <string>Proofing Rendering Intent:</string>
            </property>
           </widget>
          </item>
          <item row="2" column="0">
           <widget class="QLabel" name="lblGamutWarning">
            <property name="text">
             <string>Gamut Warning:</string>
            </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
           </widget>
          </item>
          <item row="1" column="1">
           <widget class="QSlider" name="sldAdaptationState">
            <property name="orientation">
             <enum>Qt::Horizontal</enum>
            </property>
           </widget>
          </item>
          <item row="2" column="1">
           <widget class="KisColorButton" name="gamutAlarm">
            <property name="text">
             <string/>
            </property>
           </widget>
          </item>
          <item row="3" column="1">
           <widget class="QCheckBox" name="ckbProofBlackPoint">
            <property name="text">
             <string>Black Point Compensation</string>
            </property>
           </widget>
          </item>
         </layout>
        </item>
        <item row="3" column="0">
         <spacer name="verticalSpacer_4">
          <property name="orientation">
           <enum>Qt::Vertical</enum>
          </property>
          <property name="sizeHint" stdset="0">
           <size>
            <width>20</width>
            <height>40</height>
           </size>
          </property>
         </spacer>
        </item>
        <item row="1" column="0">
         <widget class="KisColorSpaceSelector" name="proofingSpaceSelector" native="true">
          <property name="minimumSize">
           <size>
            <width>100</width>
            <height>100</height>
           </size>
          </property>
         </widget>
        </item>
        <item row="0" column="0">
         <widget class="QLabel" name="label">
          <property name="text">
           <string>Note: these are the default proofing settings for new images.</string>
          </property>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item row="1" column="0">
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
      </property>
      <property name="sizeHint" stdset="0">
       <size>
        <width>20</width>
        <height>40</height>
       </size>
      </property>
     </spacer>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KComboBox</class>
    <extends>QComboBox</extends>
    <header>kcombobox.h</header>
   </customwidget>
   <customwidget>
    <class>KisCmbIDList</class>
    <extends>QComboBox</extends>
    <header>widgets/kis_cmb_idlist.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorButton</class>
    <extends>QPushButton</extends>
    <header>kis_color_button.h</header>
   </customwidget>
   <customwidget>
    <class>KisColorSpaceSelector</class>
    <extends>QWidget</extends>
    <header>widgets/kis_color_space_selector.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <resources/>
  <connections/>
 </ui>
diff --git a/libs/ui/kis_config.cc b/libs/ui/kis_config.cc
index b0b93fdbf1..3bc1511b95 100644
--- a/libs/ui/kis_config.cc
+++ b/libs/ui/kis_config.cc
@@ -1,2248 +1,2248 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  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; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 
 #include "kis_config.h"
 
 #include <QtGlobal>
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QMutex>
 #include <QFont>
 #include <QThread>
 #include <QStringList>
 #include <QSettings>
 #include <QStandardPaths>
 #include <QDebug>
 #include <QFileInfo>
 
 #include <kconfig.h>
 
 #include <KisDocument.h>
 
 #include <KoColor.h>
 #include <KoColorSpaceRegistry.h>
 #include <KoColorModelStandardIds.h>
 #include <KoColorProfile.h>
 
 #include <kis_debug.h>
 #include <kis_types.h>
 
 #include "kis_canvas_resource_provider.h"
 #include "kis_config_notifier.h"
 #include "kis_snap_config.h"
 
 #include <config-ocio.h>
 
 #include <kis_color_manager.h>
 #include <KisOcioConfiguration.h>
 #include <KisUsageLogger.h>
 #include <kis_image_config.h>
 
 #ifdef Q_OS_WIN
 #include "config_use_qt_tablet_windows.h"
 #endif
 
 KisConfig::KisConfig(bool readOnly)
     : m_cfg( KSharedConfig::openConfig()->group(""))
     , m_readOnly(readOnly)
 {
     if (!readOnly) {
         KIS_SAFE_ASSERT_RECOVER_RETURN(qApp && qApp->thread() == QThread::currentThread());
     }
 }
 
 KisConfig::~KisConfig()
 {
     if (m_readOnly) return;
 
     if (qApp && qApp->thread() != QThread::currentThread()) {
         dbgKrita << "WARNING: KisConfig: requested config synchronization from nonGUI thread! Called from:" << kisBacktrace();
         return;
     }
 
     m_cfg.sync();
 }
 
 void KisConfig::logImportantSettings() const
 {
     KisUsageLogger::writeSysInfo("Current Settings\n");
     KisUsageLogger::writeSysInfo(QString("  Current Swap Location: %1").arg(KisImageConfig(true).swapDir()));
     KisUsageLogger::writeSysInfo(QString("  Current Swap Location writable: %1").arg(QFileInfo(KisImageConfig(true).swapDir()).isWritable() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Undo Enabled: %1").arg(undoEnabled()? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Undo Stack Limit: %1").arg(undoStackLimit()));
     KisUsageLogger::writeSysInfo(QString("  Use OpenGL: %1").arg(useOpenGL() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Use OpenGL Texture Buffer: %1").arg(useOpenGLTextureBuffer() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Use AMD Vectorization Workaround: %1").arg(enableAmdVectorizationWorkaround() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Canvas State: %1").arg(canvasState()));
     KisUsageLogger::writeSysInfo(QString("  Autosave Interval: %1").arg(autoSaveInterval()));
     KisUsageLogger::writeSysInfo(QString("  Use Backup Files: %1").arg(backupFile() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Number of Backups Kept: %1").arg(m_cfg.readEntry("numberofbackupfiles", 1)));
     KisUsageLogger::writeSysInfo(QString("  Backup File Suffix: %1").arg(m_cfg.readEntry("backupfilesuffix", "~")));
 
     QString backupDir;
     switch(m_cfg.readEntry("backupfilelocation", 0)) {
     case 1:
         backupDir = QStandardPaths::writableLocation(QStandardPaths::HomeLocation);
         break;
     case 2:
         backupDir = QStandardPaths::writableLocation(QStandardPaths::TempLocation);
         break;
     default:
         // Do nothing: the empty string is user file location
         backupDir = "Same Folder as the File";
     }
     KisUsageLogger::writeSysInfo(QString("  Backup Location: %1").arg(backupDir));
     KisUsageLogger::writeSysInfo(QString("  Backup Location writable: %1").arg(QFileInfo(backupDir).isWritable() ? "true" : "false"));
 
     KisUsageLogger::writeSysInfo(QString("  Use Win8 Pointer Input: %1").arg(useWin8PointerInput() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Use RightMiddleTabletButton Workaround: %1").arg(useRightMiddleTabletButtonWorkaround() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Levels of Detail Enabled: %1").arg(levelOfDetailEnabled() ? "true" : "false"));
     KisUsageLogger::writeSysInfo(QString("  Use Zip64: %1").arg(useZip64() ? "true" : "false"));
 
     KisUsageLogger::writeSysInfo("\n");
 }
 
 bool KisConfig::disableTouchOnCanvas(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableTouchOnCanvas", false));
 }
 
 void KisConfig::setDisableTouchOnCanvas(bool value) const
 {
     m_cfg.writeEntry("disableTouchOnCanvas", value);
 }
 
 bool KisConfig::disableTouchRotation(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableTouchRotation", false));
 }
 
 void KisConfig::setDisableTouchRotation(bool value) const
 {
     m_cfg.writeEntry("disableTouchRotation", value);
 }
 
 bool KisConfig::useProjections(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useProjections", true));
 }
 
 void KisConfig::setUseProjections(bool useProj) const
 {
     m_cfg.writeEntry("useProjections", useProj);
 }
 
 bool KisConfig::undoEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("undoEnabled", true));
 }
 
 void KisConfig::setUndoEnabled(bool undo) const
 {
     m_cfg.writeEntry("undoEnabled", undo);
 }
 
 int KisConfig::undoStackLimit(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("undoStackLimit", 30));
 }
 
 void KisConfig::setUndoStackLimit(int limit) const
 {
     m_cfg.writeEntry("undoStackLimit", limit);
 }
 
 bool KisConfig::useCumulativeUndoRedo(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useCumulativeUndoRedo",false));
 }
 
 void KisConfig::setCumulativeUndoRedo(bool value)
 {
     m_cfg.writeEntry("useCumulativeUndoRedo", value);
 }
 
 qreal KisConfig::stackT1(bool defaultValue) const
 {
      return (defaultValue ? 5 : m_cfg.readEntry("stackT1",5));
 }
 
 void KisConfig::setStackT1(int T1)
 {
     m_cfg.writeEntry("stackT1", T1);
 }
 
 qreal KisConfig::stackT2(bool defaultValue) const
 {
      return (defaultValue ? 1 : m_cfg.readEntry("stackT2",1));
 }
 
 void KisConfig::setStackT2(int T2)
 {
     m_cfg.writeEntry("stackT2", T2);
 }
 
 int KisConfig::stackN(bool defaultValue) const
 {
     return (defaultValue ? 5 : m_cfg.readEntry("stackN",5));
 }
 
 void KisConfig::setStackN(int N)
 {
      m_cfg.writeEntry("stackN", N);
 }
 
 qint32 KisConfig::defImageWidth(bool defaultValue) const
 {
     return (defaultValue ? 1600 : m_cfg.readEntry("imageWidthDef", 1600));
 }
 
 qint32 KisConfig::defImageHeight(bool defaultValue) const
 {
     return (defaultValue ? 1200 : m_cfg.readEntry("imageHeightDef", 1200));
 }
 
 qreal KisConfig::defImageResolution(bool defaultValue) const
 {
     return (defaultValue ? 100.0 : m_cfg.readEntry("imageResolutionDef", 100.0)) / 72.0;
 }
 
+bool KisConfig::rememberLastUsedColorSpace(bool defaultValue) const
+{
+    return (defaultValue ? false : m_cfg.readEntry("rememberLastUsedColorSpace", false));
+}
+
+void KisConfig::setRememberLastUsedColorSpace(bool value) const
+{
+    m_cfg.writeEntry("rememberLastUsedColorSpace", value);
+}
+
 QString KisConfig::defColorModel(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorModelId().id()
                         : m_cfg.readEntry("colorModelDef", KoColorSpaceRegistry::instance()->rgb8()->colorModelId().id()));
 }
 
 void KisConfig::defColorModel(const QString & model) const
 {
     m_cfg.writeEntry("colorModelDef", model);
 }
 
-QString KisConfig::defaultColorDepth(bool defaultValue) const
+QString KisConfig::defColorDepth(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()
                         : m_cfg.readEntry("colorDepthDef", KoColorSpaceRegistry::instance()->rgb8()->colorDepthId().id()));
 }
 
-void KisConfig::setDefaultColorDepth(const QString & depth) const
+void KisConfig::defColorDepth(const QString & depth) const
 {
     m_cfg.writeEntry("colorDepthDef", depth);
 }
 
 QString KisConfig::defColorProfile(bool defaultValue) const
 {
     return (defaultValue ? KoColorSpaceRegistry::instance()->rgb8()->profile()->name() :
                            m_cfg.readEntry("colorProfileDef",
                                            KoColorSpaceRegistry::instance()->rgb8()->profile()->name()));
 }
 
 void KisConfig::defColorProfile(const QString & profile) const
 {
     m_cfg.writeEntry("colorProfileDef", profile);
 }
 
 void KisConfig::defImageWidth(qint32 width) const
 {
     m_cfg.writeEntry("imageWidthDef", width);
 }
 
 void KisConfig::defImageHeight(qint32 height) const
 {
     m_cfg.writeEntry("imageHeightDef", height);
 }
 
 void KisConfig::defImageResolution(qreal res) const
 {
     m_cfg.writeEntry("imageResolutionDef", res*72.0);
 }
 
 int KisConfig::preferredVectorImportResolutionPPI(bool defaultValue) const
 {
     return defaultValue ? 100.0 : m_cfg.readEntry("preferredVectorImportResolution", 100.0);
 }
 
 void KisConfig::setPreferredVectorImportResolutionPPI(int value) const
 {
     m_cfg.writeEntry("preferredVectorImportResolution", value);
 }
 
 void cleanOldCursorStyleKeys(KConfigGroup &cfg)
 {
     if (cfg.hasKey("newCursorStyle") &&
         cfg.hasKey("newOutlineStyle")) {
 
         cfg.deleteEntry("cursorStyleDef");
     }
 }
 
 CursorStyle KisConfig::newCursorStyle(bool defaultValue) const
 {
     if (defaultValue) {
         return CURSOR_STYLE_NO_CURSOR;
     }
 
 
     int style = m_cfg.readEntry("newCursorStyle", int(-1));
 
     if (style < 0) {
         // old style format
         style = m_cfg.readEntry("cursorStyleDef", int(OLD_CURSOR_STYLE_OUTLINE));
 
         switch (style) {
         case OLD_CURSOR_STYLE_TOOLICON:
             style = CURSOR_STYLE_TOOLICON;
             break;
         case OLD_CURSOR_STYLE_CROSSHAIR:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS:
             style = CURSOR_STYLE_CROSSHAIR;
             break;
         case OLD_CURSOR_STYLE_POINTER:
             style = CURSOR_STYLE_POINTER;
             break;
         case OLD_CURSOR_STYLE_OUTLINE:
         case OLD_CURSOR_STYLE_NO_CURSOR:
             style = CURSOR_STYLE_NO_CURSOR;
             break;
         case OLD_CURSOR_STYLE_SMALL_ROUND:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT:
             style = CURSOR_STYLE_SMALL_ROUND;
             break;
         case OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED:
             style = CURSOR_STYLE_TRIANGLE_RIGHTHANDED;
             break;
         case OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED:
             style = CURSOR_STYLE_TRIANGLE_LEFTHANDED;
             break;
         default:
             style = -1;
         }
     }
 
     cleanOldCursorStyleKeys(m_cfg);
 
     // compatibility with future versions
     if (style < 0 || style >= N_CURSOR_STYLE_SIZE) {
         style = CURSOR_STYLE_NO_CURSOR;
     }
 
     return (CursorStyle) style;
 }
 
 void KisConfig::setNewCursorStyle(CursorStyle style)
 {
     m_cfg.writeEntry("newCursorStyle", (int)style);
 }
 
 QColor KisConfig::getCursorMainColor(bool defaultValue) const
 {
     QColor col;
     col.setRgbF(0.501961, 1.0, 0.501961);
     return (defaultValue ? col : m_cfg.readEntry("cursorMaincColor", col));
 }
 
 void KisConfig::setCursorMainColor(const QColor &v) const
 {
     m_cfg.writeEntry("cursorMaincColor", v);
 }
 
 OutlineStyle KisConfig::newOutlineStyle(bool defaultValue) const
 {
     if (defaultValue) {
         return OUTLINE_FULL;
     }
 
     int style = m_cfg.readEntry("newOutlineStyle", int(-1));
 
     if (style < 0) {
         // old style format
         style = m_cfg.readEntry("cursorStyleDef", int(OLD_CURSOR_STYLE_OUTLINE));
 
         switch (style) {
         case OLD_CURSOR_STYLE_TOOLICON:
         case OLD_CURSOR_STYLE_CROSSHAIR:
         case OLD_CURSOR_STYLE_POINTER:
         case OLD_CURSOR_STYLE_NO_CURSOR:
         case OLD_CURSOR_STYLE_SMALL_ROUND:
         case OLD_CURSOR_STYLE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_TRIANGLE_LEFTHANDED:
             style = OUTLINE_NONE;
             break;
         case OLD_CURSOR_STYLE_OUTLINE:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_DOT:
         case OLD_CURSOR_STYLE_OUTLINE_CENTER_CROSS:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_RIGHTHANDED:
         case OLD_CURSOR_STYLE_OUTLINE_TRIANGLE_LEFTHANDED:
             style = OUTLINE_FULL;
             break;
         default:
             style = -1;
         }
     }
 
     cleanOldCursorStyleKeys(m_cfg);
 
     // compatibility with future versions
     if (style < 0 || style >= N_OUTLINE_STYLE_SIZE) {
         style = OUTLINE_FULL;
     }
 
     return (OutlineStyle) style;
 }
 
 void KisConfig::setNewOutlineStyle(OutlineStyle style)
 {
     m_cfg.writeEntry("newOutlineStyle", (int)style);
 }
 
 QRect KisConfig::colorPreviewRect() const
 {
     return m_cfg.readEntry("colorPreviewRect", QVariant(QRect(32, 32, 48, 48))).toRect();
 }
 
 void KisConfig::setColorPreviewRect(const QRect &rect)
 {
     m_cfg.writeEntry("colorPreviewRect", QVariant(rect));
 }
 
 bool KisConfig::useDirtyPresets(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useDirtyPresets", true));
 }
 void KisConfig::setUseDirtyPresets(bool value)
 {
     m_cfg.writeEntry("useDirtyPresets",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushSize(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushSize", false));
 }
 
 void KisConfig::setUseEraserBrushSize(bool value)
 {
     m_cfg.writeEntry("useEraserBrushSize",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::useEraserBrushOpacity(bool defaultValue) const
 {
    return (defaultValue ? false : m_cfg.readEntry("useEraserBrushOpacity",false));
 }
 
 void KisConfig::setUseEraserBrushOpacity(bool value)
 {
     m_cfg.writeEntry("useEraserBrushOpacity",value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 
 QString KisConfig::getMDIBackgroundColor(bool defaultValue) const
 {
     QColor col(77, 77, 77);
     KoColor kol(KoColorSpaceRegistry::instance()->rgb8());
     kol.fromQColor(col);
     QString xml = kol.toXML();
     return (defaultValue ? xml : m_cfg.readEntry("mdiBackgroundColorXML", xml));
 }
 
 void KisConfig::setMDIBackgroundColor(const QString &v) const
 {
     m_cfg.writeEntry("mdiBackgroundColorXML", v);
 }
 
 QString KisConfig::getMDIBackgroundImage(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("mdiBackgroundImage", ""));
 }
 
 void KisConfig::setMDIBackgroundImage(const QString &filename) const
 {
     m_cfg.writeEntry("mdiBackgroundImage", filename);
 }
 
 QString KisConfig::monitorProfile(int screen) const
 {
     // Note: keep this in sync with the default profile for the RGB colorspaces!
     QString profile = m_cfg.readEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), "sRGB-elle-V2-srgbtrc.icc");
     //dbgKrita << "KisConfig::monitorProfile()" << profile;
     return profile;
 }
 
 QString KisConfig::monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue) const
 {
     return (defaultValue ? defaultMonitor
                          : m_cfg.readEntry(QString("monitor_for_screen_%1").arg(screen), defaultMonitor));
 }
 
 void KisConfig::setMonitorForScreen(int screen, const QString& monitor)
 {
     m_cfg.writeEntry(QString("monitor_for_screen_%1").arg(screen), monitor);
 }
 
 void KisConfig::setMonitorProfile(int screen, const QString & monitorProfile, bool override) const
 {
     m_cfg.writeEntry("monitorProfile/OverrideX11", override);
     m_cfg.writeEntry("monitorProfile" + QString(screen == 0 ? "": QString("_%1").arg(screen)), monitorProfile);
 }
 
 const KoColorProfile *KisConfig::getScreenProfile(int screen)
 {
     if (screen < 0) return 0;
 
     KisConfig cfg(true);
     QString monitorId;
     if (KisColorManager::instance()->devices().size() > screen) {
         monitorId = cfg.monitorForScreen(screen, KisColorManager::instance()->devices()[screen]);
     }
     //dbgKrita << "getScreenProfile(). Screen" << screen << "monitor id" << monitorId;
 
     if (monitorId.isEmpty()) {
         return 0;
     }
 
     QByteArray bytes = KisColorManager::instance()->displayProfile(monitorId);
 
     //dbgKrita << "\tgetScreenProfile()" << bytes.size();
     const KoColorProfile * profile = 0;
     if (bytes.length() > 0) {
         profile = KoColorSpaceRegistry::instance()->createColorProfile(RGBAColorModelID.id(), Integer8BitsColorDepthID.id(), bytes);
         //dbgKrita << "\tKisConfig::getScreenProfile for screen" << screen << profile->name();
     }
     return profile;
 }
 
 const KoColorProfile *KisConfig::displayProfile(int screen) const
 {
     if (screen < 0) return 0;
 
     // if the user plays with the settings, they can override the display profile, in which case
     // we don't want the system setting.
     bool override = useSystemMonitorProfile();
     //dbgKrita << "KisConfig::displayProfile(). Override X11:" << override;
     const KoColorProfile *profile = 0;
     if (override) {
         //dbgKrita << "\tGoing to get the screen profile";
         profile = KisConfig::getScreenProfile(screen);
     }
 
     // if it fails. check the configuration
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tGoing to get the monitor profile";
         QString monitorProfileName = monitorProfile(screen);
         //dbgKrita << "\t\tmonitorProfileName:" << monitorProfileName;
         if (!monitorProfileName.isEmpty()) {
             profile = KoColorSpaceRegistry::instance()->profileByName(monitorProfileName);
         }
         if (profile) {
             //dbgKrita << "\t\tsuitable for display" << profile->isSuitableForDisplay();
         }
         else {
             //dbgKrita << "\t\tstill no profile";
         }
     }
     // if we still don't have a profile, or the profile isn't suitable for display,
     // we need to get a last-resort profile. the built-in sRGB is a good choice then.
     if (!profile || !profile->isSuitableForDisplay()) {
         //dbgKrita << "\tnothing worked, going to get sRGB built-in";
         profile = KoColorSpaceRegistry::instance()->profileByName("sRGB Built-in");
     }
 
     if (profile) {
         //dbgKrita << "\tKisConfig::displayProfile for screen" << screen << "is" << profile->name();
     }
     else {
         //dbgKrita << "\tCouldn't get a display profile at all";
     }
 
     return profile;
 }
 
-QString KisConfig::workingColorSpace(bool defaultValue) const
-{
-    return (defaultValue ? "RGBA" : m_cfg.readEntry("workingColorSpace", "RGBA"));
-}
-
-void KisConfig::setWorkingColorSpace(const QString & workingColorSpace) const
-{
-    m_cfg.writeEntry("workingColorSpace", workingColorSpace);
-}
-
 QString KisConfig::printerColorSpace(bool /*defaultValue*/) const
 {
     //TODO currently only rgb8 is supported
     //return (defaultValue ? "RGBA" : m_cfg.readEntry("printerColorSpace", "RGBA"));
     return QString("RGBA");
 }
 
 void KisConfig::setPrinterColorSpace(const QString & printerColorSpace) const
 {
     m_cfg.writeEntry("printerColorSpace", printerColorSpace);
 }
 
 
 QString KisConfig::printerProfile(bool defaultValue) const
 {
     return (defaultValue ? "" : m_cfg.readEntry("printerProfile", ""));
 }
 
 void KisConfig::setPrinterProfile(const QString & printerProfile) const
 {
     m_cfg.writeEntry("printerProfile", printerProfile);
 }
 
 
 bool KisConfig::useBlackPointCompensation(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useBlackPointCompensation", true));
 }
 
 void KisConfig::setUseBlackPointCompensation(bool useBlackPointCompensation) const
 {
     m_cfg.writeEntry("useBlackPointCompensation", useBlackPointCompensation);
 }
 
 bool KisConfig::allowLCMSOptimization(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("allowLCMSOptimization", true));
 }
 
 void KisConfig::setAllowLCMSOptimization(bool allowLCMSOptimization)
 {
     m_cfg.writeEntry("allowLCMSOptimization", allowLCMSOptimization);
 }
 
 bool KisConfig::forcePaletteColors(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("colorsettings/forcepalettecolors", false));
 }
 
 void KisConfig::setForcePaletteColors(bool forcePaletteColors)
 {
     m_cfg.writeEntry("colorsettings/forcepalettecolors", forcePaletteColors);
 }
 
 bool KisConfig::showRulers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showrulers", false));
 }
 
 void KisConfig::setShowRulers(bool rulers) const
 {
     m_cfg.writeEntry("showrulers", rulers);
 }
 
 bool KisConfig::forceShowSaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowSaveMessages", false));
 }
 
 void KisConfig::setForceShowSaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowSaveMessages", value);
 }
 
 bool KisConfig::forceShowAutosaveMessages(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceShowAutosaveMessages", false));
 }
 
 void KisConfig::setForceShowAutosaveMessages(bool value) const
 {
     m_cfg.writeEntry("forceShowAutosaveMessages", value);
 }
 
 bool KisConfig::rulersTrackMouse(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("rulersTrackMouse", true));
 }
 
 void KisConfig::setRulersTrackMouse(bool value) const
 {
     m_cfg.writeEntry("rulersTrackMouse", value);
 }
 
 qint32 KisConfig::pasteBehaviour(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("pasteBehaviour", 2));
 }
 
 void KisConfig::setPasteBehaviour(qint32 renderIntent) const
 {
     m_cfg.writeEntry("pasteBehaviour", renderIntent);
 }
 
 
 qint32 KisConfig::monitorRenderIntent(bool defaultValue) const
 {
     qint32 intent = m_cfg.readEntry("renderIntent", INTENT_PERCEPTUAL);
     if (intent > 3) intent = 3;
     if (intent < 0) intent = 0;
     return (defaultValue ? INTENT_PERCEPTUAL : intent);
 }
 
 void KisConfig::setRenderIntent(qint32 renderIntent) const
 {
     if (renderIntent > 3) renderIntent = 3;
     if (renderIntent < 0) renderIntent = 0;
     m_cfg.writeEntry("renderIntent", renderIntent);
 }
 
 bool KisConfig::useOpenGL(bool defaultValue) const
 {
     if (defaultValue) {
         return true;
     }
 
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return kritarc.value("OpenGLRenderer", "auto").toString() != "none";
 }
 
 void KisConfig::disableOpenGL() const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     kritarc.setValue("OpenGLRenderer", "none");
 }
 
 int KisConfig::openGLFilteringMode(bool defaultValue) const
 {
     return (defaultValue ? 3 : m_cfg.readEntry("OpenGLFilterMode", 3));
 }
 
 void KisConfig::setOpenGLFilteringMode(int filteringMode)
 {
     m_cfg.writeEntry("OpenGLFilterMode", filteringMode);
 }
 
 void KisConfig::setWidgetStyle(QString name)
 {
     m_cfg.writeEntry("widgetStyle", name);
 }
 
 QString KisConfig::widgetStyle(bool defaultValue)
 {
     return (defaultValue ? "" : m_cfg.readEntry("widgetStyle", ""));
 }
 
 bool KisConfig::useOpenGLTextureBuffer(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("useOpenGLTextureBuffer", true));
 }
 
 void KisConfig::setUseOpenGLTextureBuffer(bool useBuffer)
 {
     m_cfg.writeEntry("useOpenGLTextureBuffer", useBuffer);
 }
 
 int KisConfig::openGLTextureSize(bool defaultValue) const
 {
     return (defaultValue ? 256 : m_cfg.readEntry("textureSize", 256));
 }
 
 bool KisConfig::disableVSync(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("disableVSync", true));
 }
 
 void KisConfig::setDisableVSync(bool disableVSync)
 {
     m_cfg.writeEntry("disableVSync", disableVSync);
 }
 
 bool KisConfig::showAdvancedOpenGLSettings(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showAdvancedOpenGLSettings", false));
 }
 
 bool KisConfig::forceOpenGLFenceWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceOpenGLFenceWorkaround", false));
 }
 
 int KisConfig::numMipmapLevels(bool defaultValue) const
 {
     return (defaultValue ? 4 : m_cfg.readEntry("numMipmapLevels", 4));
 }
 
 int KisConfig::textureOverlapBorder() const
 {
     return 1 << qMax(0, numMipmapLevels());
 }
 
 quint32 KisConfig::getGridMainStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("gridmainstyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGridMainStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridmainstyle", v);
 }
 
 quint32 KisConfig::getGridSubdivisionStyle(bool defaultValue) const
 {
     quint32 v = m_cfg.readEntry("gridsubdivisionstyle", 1);
     if (v > 2) v = 2;
     return (defaultValue ? 1 : v);
 }
 
 void KisConfig::setGridSubdivisionStyle(quint32 v) const
 {
     m_cfg.writeEntry("gridsubdivisionstyle", v);
 }
 
 QColor KisConfig::getGridMainColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("gridmaincolor", col));
 }
 
 void KisConfig::setGridMainColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridmaincolor", v);
 }
 
 QColor KisConfig::getGridSubdivisionColor(bool defaultValue) const
 {
     QColor col(150, 150, 150);
     return (defaultValue ? col : m_cfg.readEntry("gridsubdivisioncolor", col));
 }
 
 void KisConfig::setGridSubdivisionColor(const QColor & v) const
 {
     m_cfg.writeEntry("gridsubdivisioncolor", v);
 }
 
 QColor KisConfig::getPixelGridColor(bool defaultValue) const
 {
     QColor col(255, 255, 255);
     return (defaultValue ? col : m_cfg.readEntry("pixelGridColor", col));
 }
 
 void KisConfig::setPixelGridColor(const QColor & v) const
 {
     m_cfg.writeEntry("pixelGridColor", v);
 }
 
 qreal KisConfig::getPixelGridDrawingThreshold(bool defaultValue) const
 {
     qreal border = 24.0f;
     return (defaultValue ? border : m_cfg.readEntry("pixelGridDrawingThreshold", border));
 }
 
 void KisConfig::setPixelGridDrawingThreshold(qreal v) const
 {
     m_cfg.writeEntry("pixelGridDrawingThreshold", v);
 }
 
 bool KisConfig::pixelGridEnabled(bool defaultValue) const
 {
     bool enabled = true;
     return (defaultValue ? enabled : m_cfg.readEntry("pixelGridEnabled", enabled));
 }
 
 void KisConfig::enablePixelGrid(bool v) const
 {
     m_cfg.writeEntry("pixelGridEnabled", v);
 }
 
 quint32 KisConfig::guidesLineStyle(bool defaultValue) const
 {
     int v = m_cfg.readEntry("guidesLineStyle", 0);
     v = qBound(0, v, 2);
     return (defaultValue ? 0 : v);
 }
 
 void KisConfig::setGuidesLineStyle(quint32 v) const
 {
     m_cfg.writeEntry("guidesLineStyle", v);
 }
 
 QColor KisConfig::guidesColor(bool defaultValue) const
 {
     QColor col(99, 99, 99);
     return (defaultValue ? col : m_cfg.readEntry("guidesColor", col));
 }
 
 void KisConfig::setGuidesColor(const QColor & v) const
 {
     m_cfg.writeEntry("guidesColor", v);
 }
 
 void KisConfig::loadSnapConfig(KisSnapConfig *config, bool defaultValue) const
 {
     KisSnapConfig defaultConfig(false);
 
     if (defaultValue) {
         *config = defaultConfig;
         return;
     }
 
     config->setOrthogonal(m_cfg.readEntry("globalSnapOrthogonal", defaultConfig.orthogonal()));
     config->setNode(m_cfg.readEntry("globalSnapNode", defaultConfig.node()));
     config->setExtension(m_cfg.readEntry("globalSnapExtension", defaultConfig.extension()));
     config->setIntersection(m_cfg.readEntry("globalSnapIntersection", defaultConfig.intersection()));
     config->setBoundingBox(m_cfg.readEntry("globalSnapBoundingBox", defaultConfig.boundingBox()));
     config->setImageBounds(m_cfg.readEntry("globalSnapImageBounds", defaultConfig.imageBounds()));
     config->setImageCenter(m_cfg.readEntry("globalSnapImageCenter", defaultConfig.imageCenter()));
     config->setToPixel(m_cfg.readEntry("globalSnapToPixel", defaultConfig.toPixel()));
 }
 
 void KisConfig::saveSnapConfig(const KisSnapConfig &config)
 {
     m_cfg.writeEntry("globalSnapOrthogonal", config.orthogonal());
     m_cfg.writeEntry("globalSnapNode", config.node());
     m_cfg.writeEntry("globalSnapExtension", config.extension());
     m_cfg.writeEntry("globalSnapIntersection", config.intersection());
     m_cfg.writeEntry("globalSnapBoundingBox", config.boundingBox());
     m_cfg.writeEntry("globalSnapImageBounds", config.imageBounds());
     m_cfg.writeEntry("globalSnapImageCenter", config.imageCenter());
     m_cfg.writeEntry("globalSnapToPixel", config.toPixel());
 }
 
 qint32 KisConfig::checkSize(bool defaultValue) const
 {
     qint32 size = (defaultValue ? 32 : m_cfg.readEntry("checksize", 32));
     if (size == 0) size = 32;
     return size;
 }
 
 void KisConfig::setCheckSize(qint32 checksize) const
 {
     if (checksize == 0) {
         checksize = 32;
     }
     m_cfg.writeEntry("checksize", checksize);
 }
 
 bool KisConfig::scrollCheckers(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("scrollingcheckers", false));
 }
 
 void KisConfig::setScrollingCheckers(bool sc) const
 {
     m_cfg.writeEntry("scrollingcheckers", sc);
 }
 
 QColor KisConfig::canvasBorderColor(bool defaultValue) const
 {
     QColor color(QColor(128,128,128));
     return (defaultValue ? color : m_cfg.readEntry("canvasBorderColor", color));
 }
 
 void KisConfig::setCanvasBorderColor(const QColor& color) const
 {
     m_cfg.writeEntry("canvasBorderColor", color);
 }
 
 bool KisConfig::hideScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hideScrollbars", false));
 }
 
 void KisConfig::setHideScrollbars(bool value) const
 {
     m_cfg.writeEntry("hideScrollbars", value);
 }
 
 
 QColor KisConfig::checkersColor1(bool defaultValue) const
 {
     QColor col(220, 220, 220);
     return (defaultValue ? col : m_cfg.readEntry("checkerscolor", col));
 }
 
 void KisConfig::setCheckersColor1(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor", v);
 }
 
 QColor KisConfig::checkersColor2(bool defaultValue) const
 {
     return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("checkerscolor2", QColor(Qt::white)));
 }
 
 void KisConfig::setCheckersColor2(const QColor & v) const
 {
     m_cfg.writeEntry("checkerscolor2", v);
 }
 
 bool KisConfig::antialiasCurves(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("antialiascurves", true));
 }
 
 void KisConfig::setAntialiasCurves(bool v) const
 {
     m_cfg.writeEntry("antialiascurves", v);
 }
 
 bool KisConfig::antialiasSelectionOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("AntialiasSelectionOutline", false));
 }
 
 void KisConfig::setAntialiasSelectionOutline(bool v) const
 {
     m_cfg.writeEntry("AntialiasSelectionOutline", v);
 }
 
 bool KisConfig::showRootLayer(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowRootLayer", false));
 }
 
 void KisConfig::setShowRootLayer(bool showRootLayer) const
 {
     m_cfg.writeEntry("ShowRootLayer", showRootLayer);
 }
 
 bool KisConfig::showGlobalSelection(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ShowGlobalSelection", false));
 }
 
 void KisConfig::setShowGlobalSelection(bool showGlobalSelection) const
 {
     m_cfg.writeEntry("ShowGlobalSelection", showGlobalSelection);
 }
 
 bool KisConfig::showOutlineWhilePainting(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ShowOutlineWhilePainting", true));
 }
 
 void KisConfig::setShowOutlineWhilePainting(bool showOutlineWhilePainting) const
 {
     m_cfg.writeEntry("ShowOutlineWhilePainting", showOutlineWhilePainting);
 }
 
 bool KisConfig::forceAlwaysFullSizedOutline(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("forceAlwaysFullSizedOutline", false));
 }
 
 void KisConfig::setForceAlwaysFullSizedOutline(bool value) const
 {
     m_cfg.writeEntry("forceAlwaysFullSizedOutline", value);
 }
 
 KisConfig::SessionOnStartup KisConfig::sessionOnStartup(bool defaultValue) const
 {
     int value = defaultValue ? SOS_BlankSession : m_cfg.readEntry("sessionOnStartup", (int)SOS_BlankSession);
     return (KisConfig::SessionOnStartup)value;
 }
 void KisConfig::setSessionOnStartup(SessionOnStartup value)
 {
     m_cfg.writeEntry("sessionOnStartup", (int)value);
 }
 
 bool KisConfig::saveSessionOnQuit(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("saveSessionOnQuit", false);
 }
 void KisConfig::setSaveSessionOnQuit(bool value)
 {
     m_cfg.writeEntry("saveSessionOnQuit", value);
 }
 
 qreal KisConfig::outlineSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 1.0 : m_cfg.readEntry("OutlineSizeMinimum", 1.0));
 }
 
 void KisConfig::setOutlineSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("OutlineSizeMinimum", outlineSizeMinimum);
 }
 
 qreal KisConfig::selectionViewSizeMinimum(bool defaultValue) const
 {
     return (defaultValue ? 5.0 : m_cfg.readEntry("SelectionViewSizeMinimum", 5.0));
 }
 
 void KisConfig::setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const
 {
     m_cfg.writeEntry("SelectionViewSizeMinimum", outlineSizeMinimum);
 }
 
 int KisConfig::autoSaveInterval(bool defaultValue)  const
 {
     return (defaultValue ? 15 * 60 : m_cfg.readEntry("AutoSaveInterval", 15 * 60));
 }
 
 void KisConfig::setAutoSaveInterval(int seconds)  const
 {
     return m_cfg.writeEntry("AutoSaveInterval", seconds);
 }
 
 bool KisConfig::backupFile(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("CreateBackupFile", true));
 }
 
 void KisConfig::setBackupFile(bool backupFile) const
 {
     m_cfg.writeEntry("CreateBackupFile", backupFile);
 }
 
 bool KisConfig::showFilterGallery(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showFilterGallery", false));
 }
 
 void KisConfig::setShowFilterGallery(bool showFilterGallery) const
 {
     m_cfg.writeEntry("showFilterGallery", showFilterGallery);
 }
 
 bool KisConfig::showFilterGalleryLayerMaskDialog(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showFilterGalleryLayerMaskDialog", true));
 }
 
 void KisConfig::setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const
 {
     m_cfg.writeEntry("setShowFilterGalleryLayerMaskDialog", showFilterGallery);
 }
 
 QString KisConfig::canvasState(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
     return (defaultValue ? "OPENGL_NOT_TRIED" : kritarc.value("canvasState", "OPENGL_NOT_TRIED").toString());
 }
 
 void KisConfig::setCanvasState(const QString& state) const
 {
     static QStringList acceptableStates;
     if (acceptableStates.isEmpty()) {
         acceptableStates << "OPENGL_SUCCESS" << "TRY_OPENGL" << "OPENGL_NOT_TRIED" << "OPENGL_FAILED";
     }
     if (acceptableStates.contains(state)) {
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         kritarc.setValue("canvasState", state);
     }
 }
 
 bool KisConfig::toolOptionsPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ToolOptionsPopupDetached", false));
 }
 
 void KisConfig::setToolOptionsPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("ToolOptionsPopupDetached", detached);
 }
 
 
 bool KisConfig::paintopPopupDetached(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("PaintopPopupDetached", false));
 }
 
 void KisConfig::setPaintopPopupDetached(bool detached) const
 {
     m_cfg.writeEntry("PaintopPopupDetached", detached);
 }
 
 QString KisConfig::pressureTabletCurve(bool defaultValue) const
 {
     return (defaultValue ? "0,0;1,1" : m_cfg.readEntry("tabletPressureCurve","0,0;1,1;"));
 }
 
 void KisConfig::setPressureTabletCurve(const QString& curveString) const
 {
     m_cfg.writeEntry("tabletPressureCurve", curveString);
 }
 
 bool KisConfig::useWin8PointerInput(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
 #ifdef USE_QT_TABLET_WINDOWS
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return useWin8PointerInputNoApp(&kritarc, defaultValue);
 #else
     return (defaultValue ? false : m_cfg.readEntry("useWin8PointerInput", false));
 #endif
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseWin8PointerInput(bool value)
 {
 #ifdef Q_OS_WIN
 
     // Special handling: Only set value if changed
     // I don't want it to be set if the user hasn't touched it
     if (useWin8PointerInput() != value) {
 
 #ifdef USE_QT_TABLET_WINDOWS
         const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
         QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
         setUseWin8PointerInputNoApp(&kritarc, value);
 #else
         m_cfg.writeEntry("useWin8PointerInput", value);
 #endif
 
     }
 
 #else
     Q_UNUSED(value)
 #endif
 }
 
 bool KisConfig::useWin8PointerInputNoApp(QSettings *settings, bool defaultValue)
 {
     return defaultValue ? false : settings->value("useWin8PointerInput", false).toBool();
 }
 
 void KisConfig::setUseWin8PointerInputNoApp(QSettings *settings, bool value)
 {
     settings->setValue("useWin8PointerInput", value);
 }
 
 bool KisConfig::useRightMiddleTabletButtonWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("useRightMiddleTabletButtonWorkaround", false));
 }
 
 void KisConfig::setUseRightMiddleTabletButtonWorkaround(bool value)
 {
     m_cfg.writeEntry("useRightMiddleTabletButtonWorkaround", value);
 }
 
 qreal KisConfig::vastScrolling(bool defaultValue) const
 {
     return (defaultValue ? 0.9 : m_cfg.readEntry("vastScrolling", 0.9));
 }
 
 void KisConfig::setVastScrolling(const qreal factor) const
 {
     m_cfg.writeEntry("vastScrolling", factor);
 }
 
 int KisConfig::presetChooserViewMode(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("presetChooserViewMode", 0));
 }
 
 void KisConfig::setPresetChooserViewMode(const int mode) const
 {
     m_cfg.writeEntry("presetChooserViewMode", mode);
 }
 
 int KisConfig::presetIconSize(bool defaultValue) const
 {
     return (defaultValue ? 60 : m_cfg.readEntry("presetIconSize", 60));
 }
 
 void KisConfig::setPresetIconSize(const int value) const
 {
     m_cfg.writeEntry("presetIconSize", value);
 }
 
 bool KisConfig::firstRun(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("firstRun", true));
 }
 
 void KisConfig::setFirstRun(const bool first) const
 {
     m_cfg.writeEntry("firstRun", first);
 }
 
 int KisConfig::horizontalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("horizontalSplitLines", 1));
 }
 void KisConfig::setHorizontalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("horizontalSplitLines", numberLines);
 }
 
 int KisConfig::verticalSplitLines(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("verticalSplitLines", 1));
 }
 
 void KisConfig::setVerticalSplitLines(const int numberLines) const
 {
     m_cfg.writeEntry("verticalSplitLines", numberLines);
 }
 
 bool KisConfig::clicklessSpacePan(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("clicklessSpacePan", true));
 }
 
 void KisConfig::setClicklessSpacePan(const bool toggle) const
 {
     m_cfg.writeEntry("clicklessSpacePan", toggle);
 }
 
 
 bool KisConfig::hideDockersFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideDockersFullScreen", true));
 }
 
 void KisConfig::setHideDockersFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideDockersFullScreen", value);
 }
 
 bool KisConfig::showDockers(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showDockers", true));
 }
 
 void KisConfig::setShowDockers(const bool value) const
 {
     m_cfg.writeEntry("showDockers", value);
 }
 
 bool KisConfig::showStatusBar(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showStatusBar", true));
 }
 
 void KisConfig::setShowStatusBar(const bool value) const
 {
     m_cfg.writeEntry("showStatusBar", value);
 }
 
 bool KisConfig::hideMenuFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideMenuFullScreen", true));
 }
 
 void KisConfig::setHideMenuFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideMenuFullScreen", value);
 }
 
 bool KisConfig::hideScrollbarsFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideScrollbarsFullScreen", true));
 }
 
 void KisConfig::setHideScrollbarsFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideScrollbarsFullScreen", value);
 }
 
 bool KisConfig::hideStatusbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true: m_cfg.readEntry("hideStatusbarFullScreen", true));
 }
 
 void KisConfig::setHideStatusbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideStatusbarFullScreen", value);
 }
 
 bool KisConfig::hideTitlebarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideTitleBarFullscreen", true));
 }
 
 void KisConfig::setHideTitlebarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideTitleBarFullscreen", value);
 }
 
 bool KisConfig::hideToolbarFullscreen(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("hideToolbarFullscreen", true));
 }
 
 void KisConfig::setHideToolbarFullscreen(const bool value) const
 {
     m_cfg.writeEntry("hideToolbarFullscreen", value);
 }
 
 bool KisConfig::fullscreenMode(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("fullscreenMode", true));
 }
 
 void KisConfig::setFullscreenMode(const bool value) const
 {
     m_cfg.writeEntry("fullscreenMode", value);
 }
 
 QStringList KisConfig::favoriteCompositeOps(bool defaultValue) const
 {
     return (defaultValue ? QStringList() :
                            m_cfg.readEntry("favoriteCompositeOps",
                                            QString("normal,erase,multiply,burn,darken,add,dodge,screen,overlay,soft_light_svg,luminize,lighten,saturation,color,divide").split(',')));
 }
 
 void KisConfig::setFavoriteCompositeOps(const QStringList& compositeOps) const
 {
     m_cfg.writeEntry("favoriteCompositeOps", compositeOps);
 }
 
 QString KisConfig::exportConfigurationXML(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ExportConfiguration-" + filterId, QString()));
 }
 
 KisPropertiesConfigurationSP KisConfig::exportConfiguration(const QString &filterId, bool defaultValue) const
 {
     KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
     const QString xmlData = exportConfigurationXML(filterId, defaultValue);
     cfg->fromXML(xmlData);
     return cfg;
 }
 
 void KisConfig::setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString exportConfig = properties->toXML();
     m_cfg.writeEntry("ExportConfiguration-" + filterId, exportConfig);
 }
 
 QString KisConfig::importConfiguration(const QString &filterId, bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("ImportConfiguration-" + filterId, QString()));
 }
 
 void KisConfig::setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const
 {
     QString importConfig = properties->toXML();
     m_cfg.writeEntry("ImportConfiguration-" + filterId, importConfig);
 }
 
 bool KisConfig::useOcio(bool defaultValue) const
 {
 #ifdef HAVE_OCIO
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/UseOcio", false));
 #else
     Q_UNUSED(defaultValue);
     return false;
 #endif
 }
 
 void KisConfig::setUseOcio(bool useOCIO) const
 {
     m_cfg.writeEntry("Krita/Ocio/UseOcio", useOCIO);
 }
 
 int KisConfig::favoritePresets(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("numFavoritePresets", 10));
 }
 
 void KisConfig::setFavoritePresets(const int value)
 {
     m_cfg.writeEntry("numFavoritePresets", value);
 }
 
 bool KisConfig::levelOfDetailEnabled(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("levelOfDetailEnabled", false));
 }
 
 void KisConfig::setLevelOfDetailEnabled(bool value)
 {
     m_cfg.writeEntry("levelOfDetailEnabled", value);
 }
 
 KisOcioConfiguration KisConfig::ocioConfiguration(bool defaultValue) const
 {
     KisOcioConfiguration cfg;
 
     if (!defaultValue) {
         cfg.mode = (KisOcioConfiguration::Mode)m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", 0);
         cfg.configurationPath = m_cfg.readEntry("Krita/Ocio/OcioConfigPath", QString());
         cfg.lutPath = m_cfg.readEntry("Krita/Ocio/OcioLutPath", QString());
         cfg.inputColorSpace = m_cfg.readEntry("Krita/Ocio/InputColorSpace", QString());
         cfg.displayDevice = m_cfg.readEntry("Krita/Ocio/DisplayDevice", QString());
         cfg.displayView = m_cfg.readEntry("Krita/Ocio/DisplayView", QString());
         cfg.look = m_cfg.readEntry("Krita/Ocio/DisplayLook", QString());
     }
 
     return cfg;
 }
 
 void KisConfig::setOcioConfiguration(const KisOcioConfiguration &cfg)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) cfg.mode);
     m_cfg.writeEntry("Krita/Ocio/OcioConfigPath", cfg.configurationPath);
     m_cfg.writeEntry("Krita/Ocio/OcioLutPath", cfg.lutPath);
     m_cfg.writeEntry("Krita/Ocio/InputColorSpace", cfg.inputColorSpace);
     m_cfg.writeEntry("Krita/Ocio/DisplayDevice", cfg.displayDevice);
     m_cfg.writeEntry("Krita/Ocio/DisplayView", cfg.displayView);
     m_cfg.writeEntry("Krita/Ocio/DisplayLook", cfg.look);
 }
 
 KisConfig::OcioColorManagementMode
 KisConfig::ocioColorManagementMode(bool defaultValue) const
 {
     // FIXME: this option duplicates ocioConfiguration(), please deprecate it
     return (OcioColorManagementMode)(defaultValue ? INTERNAL
                                                   : m_cfg.readEntry("Krita/Ocio/OcioColorManagementMode", (int) INTERNAL));
 }
 
 void KisConfig::setOcioColorManagementMode(OcioColorManagementMode mode) const
 {
     // FIXME: this option duplicates ocioConfiguration(), please deprecate it
     m_cfg.writeEntry("Krita/Ocio/OcioColorManagementMode", (int) mode);
 }
 
 int KisConfig::ocioLutEdgeSize(bool defaultValue) const
 {
     return (defaultValue ? 64 : m_cfg.readEntry("Krita/Ocio/LutEdgeSize", 64));
 }
 
 void KisConfig::setOcioLutEdgeSize(int value)
 {
     m_cfg.writeEntry("Krita/Ocio/LutEdgeSize", value);
 }
 
 bool KisConfig::ocioLockColorVisualRepresentation(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("Krita/Ocio/OcioLockColorVisualRepresentation", false));
 }
 
 void KisConfig::setOcioLockColorVisualRepresentation(bool value)
 {
     m_cfg.writeEntry("Krita/Ocio/OcioLockColorVisualRepresentation", value);
 }
 
 QString KisConfig::defaultPalette(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("defaultPalette", "Default"));
 }
 
 void KisConfig::setDefaultPalette(const QString& name) const
 {
     m_cfg.writeEntry("defaultPalette", name);
 }
 
 QString KisConfig::toolbarSlider(int sliderNumber, bool defaultValue) const
 {
     QString def = "flow";
     if (sliderNumber == 1) {
         def = "opacity";
     }
     if (sliderNumber == 2) {
         def = "size";
     }
     return (defaultValue ? def : m_cfg.readEntry(QString("toolbarslider_%1").arg(sliderNumber), def));
 }
 
 void KisConfig::setToolbarSlider(int sliderNumber, const QString &slider)
 {
     m_cfg.writeEntry(QString("toolbarslider_%1").arg(sliderNumber), slider);
 }
 
 int KisConfig::layerThumbnailSize(bool defaultValue) const
 {
     return (defaultValue ? 20 : m_cfg.readEntry("layerThumbnailSize", 20));
 }
 
 void KisConfig::setLayerThumbnailSize(int size)
 {
     m_cfg.writeEntry("layerThumbnailSize", size);
 }
 
 bool KisConfig::sliderLabels(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("sliderLabels", true));
 }
 
 void KisConfig::setSliderLabels(bool enabled)
 {
     m_cfg.writeEntry("sliderLabels", enabled);
 }
 
 QString KisConfig::currentInputProfile(bool defaultValue) const
 {
     return (defaultValue ? QString() : m_cfg.readEntry("currentInputProfile", QString()));
 }
 
 void KisConfig::setCurrentInputProfile(const QString& name)
 {
     m_cfg.writeEntry("currentInputProfile", name);
 }
 
 bool KisConfig::useSystemMonitorProfile(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("ColorManagement/UseSystemMonitorProfile", false));
 }
 
 void KisConfig::setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const
 {
     m_cfg.writeEntry("ColorManagement/UseSystemMonitorProfile", _useSystemMonitorProfile);
 }
 
 bool KisConfig::presetStripVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("presetStripVisible", true));
 }
 
 void KisConfig::setPresetStripVisible(bool visible)
 {
     m_cfg.writeEntry("presetStripVisible", visible);
 }
 
 bool KisConfig::scratchpadVisible(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("scratchpadVisible", true));
 }
 
 void KisConfig::setScratchpadVisible(bool visible)
 {
     m_cfg.writeEntry("scratchpadVisible", visible);
 }
 
 bool KisConfig::showSingleChannelAsColor(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("showSingleChannelAsColor", false));
 }
 
 void KisConfig::setShowSingleChannelAsColor(bool asColor)
 {
     m_cfg.writeEntry("showSingleChannelAsColor", asColor);
 }
 
 bool KisConfig::hidePopups(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("hidePopups", false));
 }
 
 void KisConfig::setHidePopups(bool hidepopups)
 {
     m_cfg.writeEntry("hidePopups", hidepopups);
 }
 
 int KisConfig::numDefaultLayers(bool defaultValue) const
 {
     return (defaultValue ? 2 : m_cfg.readEntry("NumberOfLayersForNewImage", 2));
 }
 
 void KisConfig::setNumDefaultLayers(int num)
 {
     m_cfg.writeEntry("NumberOfLayersForNewImage", num);
 }
 
 quint8 KisConfig::defaultBackgroundOpacity(bool defaultValue) const
 {
   return (defaultValue ? (int)OPACITY_OPAQUE_U8 : m_cfg.readEntry("BackgroundOpacityForNewImage", (int)OPACITY_OPAQUE_U8));
 }
 
 void KisConfig::setDefaultBackgroundOpacity(quint8 value)
 {
   m_cfg.writeEntry("BackgroundOpacityForNewImage", (int)value);
 }
 
 QColor KisConfig::defaultBackgroundColor(bool defaultValue) const
 {
   return (defaultValue ? QColor(Qt::white) : m_cfg.readEntry("BackgroundColorForNewImage", QColor(Qt::white)));
 }
 
 void KisConfig::setDefaultBackgroundColor(const QColor &value)
 {
   m_cfg.writeEntry("BackgroundColorForNewImage", value);
 }
 
 KisConfig::BackgroundStyle KisConfig::defaultBackgroundStyle(bool defaultValue) const
 {
   return (KisConfig::BackgroundStyle)(defaultValue ? RASTER_LAYER : m_cfg.readEntry("BackgroundStyleForNewImage", (int)RASTER_LAYER));
 }
 
 void KisConfig::setDefaultBackgroundStyle(KisConfig::BackgroundStyle value)
 {
   m_cfg.writeEntry("BackgroundStyleForNewImage", (int)value);
 }
 
 int KisConfig::lineSmoothingType(bool defaultValue) const
 {
     return (defaultValue ? 1 : m_cfg.readEntry("LineSmoothingType", 1));
 }
 
 void KisConfig::setLineSmoothingType(int value)
 {
     m_cfg.writeEntry("LineSmoothingType", value);
 }
 
 qreal KisConfig::lineSmoothingDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDistance", value);
 }
 
 qreal KisConfig::lineSmoothingTailAggressiveness(bool defaultValue) const
 {
     return (defaultValue ? 0.15 : m_cfg.readEntry("LineSmoothingTailAggressiveness", 0.15));
 }
 
 void KisConfig::setLineSmoothingTailAggressiveness(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingTailAggressiveness", value);
 }
 
 bool KisConfig::lineSmoothingSmoothPressure(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("LineSmoothingSmoothPressure", false));
 }
 
 void KisConfig::setLineSmoothingSmoothPressure(bool value)
 {
     m_cfg.writeEntry("LineSmoothingSmoothPressure", value);
 }
 
 bool KisConfig::lineSmoothingScalableDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingScalableDistance", true));
 }
 
 void KisConfig::setLineSmoothingScalableDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingScalableDistance", value);
 }
 
 qreal KisConfig::lineSmoothingDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? 50.0 : m_cfg.readEntry("LineSmoothingDelayDistance", 50.0));
 }
 
 void KisConfig::setLineSmoothingDelayDistance(qreal value)
 {
     m_cfg.writeEntry("LineSmoothingDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingUseDelayDistance(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingUseDelayDistance", true));
 }
 
 void KisConfig::setLineSmoothingUseDelayDistance(bool value)
 {
     m_cfg.writeEntry("LineSmoothingUseDelayDistance", value);
 }
 
 bool KisConfig::lineSmoothingFinishStabilizedCurve(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingFinishStabilizedCurve", true));
 }
 
 void KisConfig::setLineSmoothingFinishStabilizedCurve(bool value)
 {
     m_cfg.writeEntry("LineSmoothingFinishStabilizedCurve", value);
 }
 
 bool KisConfig::lineSmoothingStabilizeSensors(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("LineSmoothingStabilizeSensors", true));
 }
 
 void KisConfig::setLineSmoothingStabilizeSensors(bool value)
 {
     m_cfg.writeEntry("LineSmoothingStabilizeSensors", value);
 }
 
 int KisConfig::tabletEventsDelay(bool defaultValue) const
 {
     return (defaultValue ? 10 : m_cfg.readEntry("tabletEventsDelay", 10));
 }
 
 void KisConfig::setTabletEventsDelay(int value)
 {
     m_cfg.writeEntry("tabletEventsDelay", value);
 }
 
 bool KisConfig::trackTabletEventLatency(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("trackTabletEventLatency", false));
 }
 
 void KisConfig::setTrackTabletEventLatency(bool value)
 {
     m_cfg.writeEntry("trackTabletEventLatency", value);
 }
 
 bool KisConfig::testingAcceptCompressedTabletEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingAcceptCompressedTabletEvents", false));
 }
 
 void KisConfig::setTestingAcceptCompressedTabletEvents(bool value)
 {
     m_cfg.writeEntry("testingAcceptCompressedTabletEvents", value);
 }
 
 bool KisConfig::shouldEatDriverShortcuts(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("shouldEatDriverShortcuts", false));
 }
 
 bool KisConfig::testingCompressBrushEvents(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("testingCompressBrushEvents", false));
 }
 
 void KisConfig::setTestingCompressBrushEvents(bool value)
 {
     m_cfg.writeEntry("testingCompressBrushEvents", value);
 }
 
 int KisConfig::workaroundX11SmoothPressureSteps(bool defaultValue) const
 {
     return (defaultValue ? 0 : m_cfg.readEntry("workaroundX11SmoothPressureSteps", 0));
 }
 
 bool KisConfig::showCanvasMessages(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("showOnCanvasMessages", true));
 }
 
 void KisConfig::setShowCanvasMessages(bool show)
 {
     m_cfg.writeEntry("showOnCanvasMessages", show);
 }
 
 bool KisConfig::compressKra(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("compressLayersInKra", false));
 }
 
 void KisConfig::setCompressKra(bool compress)
 {
     m_cfg.writeEntry("compressLayersInKra", compress);
 }
 
 bool KisConfig::trimKra(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("TrimKra", false));
 }
 
 void KisConfig::setTrimKra(bool trim)
 {
     m_cfg.writeEntry("TrimKra", trim);
 }
 
 bool KisConfig::toolOptionsInDocker(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("ToolOptionsInDocker", true));
 }
 
 void KisConfig::setToolOptionsInDocker(bool inDocker)
 {
     m_cfg.writeEntry("ToolOptionsInDocker", inDocker);
 }
 
 bool KisConfig::kineticScrollingEnabled(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("KineticScrollingEnabled", true));
 }
 
 void KisConfig::setKineticScrollingEnabled(bool value)
 {
     m_cfg.writeEntry("KineticScrollingEnabled", value);
 }
 
 int KisConfig::kineticScrollingGesture(bool defaultValue) const
 {
 #ifdef Q_OS_ANDROID
     int defaultGesture = 0; // TouchGesture
 #else
     int defaultGesture = 2; // MiddleMouseButtonGesture
 #endif
 
     return (defaultValue ? defaultGesture : m_cfg.readEntry("KineticScrollingGesture", defaultGesture));
 }
 
 void KisConfig::setKineticScrollingGesture(int gesture)
 {
     m_cfg.writeEntry("KineticScrollingGesture", gesture);
 }
 
 int KisConfig::kineticScrollingSensitivity(bool defaultValue) const
 {
     return (defaultValue ? 75 : m_cfg.readEntry("KineticScrollingSensitivity", 75));
 }
 
 void KisConfig::setKineticScrollingSensitivity(int sensitivity)
 {
     m_cfg.writeEntry("KineticScrollingSensitivity", sensitivity);
 }
 
 bool KisConfig::kineticScrollingHiddenScrollbars(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("KineticScrollingHideScrollbar", false));
 }
 
 void KisConfig::setKineticScrollingHideScrollbars(bool scrollbar)
 {
     m_cfg.writeEntry("KineticScrollingHideScrollbar", scrollbar);
 }
 
 const KoColorSpace* KisConfig::customColorSelectorColorSpace(bool defaultValue) const
 {
     const KoColorSpace *cs = 0;
 
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     if (defaultValue || cfg.readEntry("useCustomColorSpace", true)) {
         KoColorSpaceRegistry* csr = KoColorSpaceRegistry::instance();
         QString modelID = cfg.readEntry("customColorSpaceModel", "RGBA");
         QString depthID = cfg.readEntry("customColorSpaceDepthID", "U8");
         QString profile = cfg.readEntry("customColorSpaceProfile", "sRGB built-in - (lcms internal)");
         if (profile == "default") {
           // qDebug() << "Falling back to default color profile.";
           profile = "sRGB built-in - (lcms internal)";
         }
         cs = csr->colorSpace(modelID, depthID, profile);
     }
 
     return cs;
 }
 
 void KisConfig::setCustomColorSelectorColorSpace(const KoColorSpace *cs)
 {
     KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
     cfg.writeEntry("useCustomColorSpace", bool(cs));
     if(cs) {
         cfg.writeEntry("customColorSpaceModel", cs->colorModelId().id());
         cfg.writeEntry("customColorSpaceDepthID", cs->colorDepthId().id());
         cfg.writeEntry("customColorSpaceProfile", cs->profile()->name());
     }
 
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::enableOpenGLFramerateLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableOpenGLFramerateLogging", false));
 }
 
 void KisConfig::setEnableOpenGLFramerateLogging(bool value) const
 {
     m_cfg.writeEntry("enableOpenGLFramerateLogging", value);
 }
 
 bool KisConfig::enableBrushSpeedLogging(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("enableBrushSpeedLogging", false));
 }
 
 void KisConfig::setEnableBrushSpeedLogging(bool value) const
 {
     m_cfg.writeEntry("enableBrushSpeedLogging", value);
 }
 
 void KisConfig::setEnableAmdVectorizationWorkaround(bool value)
 {
     m_cfg.writeEntry("amdDisableVectorWorkaround", value);
 }
 
 bool KisConfig::enableAmdVectorizationWorkaround(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("amdDisableVectorWorkaround", false));
 }
 
 void KisConfig::setDisableAVXOptimizations(bool value)
 {
     m_cfg.writeEntry("disableAVXOptimizations", value);
 }
 
 bool KisConfig::disableAVXOptimizations(bool defaultValue) const
 {
     return (defaultValue ? false : m_cfg.readEntry("disableAVXOptimizations", false));
 }
 
 void KisConfig::setAnimationDropFrames(bool value)
 {
     bool oldValue = animationDropFrames();
 
     if (value == oldValue) return;
 
     m_cfg.writeEntry("animationDropFrames", value);
     KisConfigNotifier::instance()->notifyDropFramesModeChanged();
 }
 
 bool KisConfig::autoPinLayersToTimeline(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("autoPinLayers", true));
 }
 
 void KisConfig::setAutoPinLayersToTimeline(bool value)
 {
     m_cfg.writeEntry("autoPinLayers", value);
 }
 
 bool KisConfig::animationDropFrames(bool defaultValue) const
 {
     return (defaultValue ? true : m_cfg.readEntry("animationDropFrames", true));
 }
 
 int KisConfig::scrubbingUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? 30 : m_cfg.readEntry("scrubbingUpdatesDelay", 30));
 }
 
 void KisConfig::setScrubbingUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingUpdatesDelay", value);
 }
 
 int KisConfig::scrubbingAudioUpdatesDelay(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("scrubbingAudioUpdatesDelay", -1));
 }
 
 void KisConfig::setScrubbingAudioUpdatesDelay(int value)
 {
     m_cfg.writeEntry("scrubbingAudioUpdatesDelay", value);
 }
 
 int KisConfig::audioOffsetTolerance(bool defaultValue) const
 {
     return (defaultValue ? -1 : m_cfg.readEntry("audioOffsetTolerance", -1));
 }
 
 void KisConfig::setAudioOffsetTolerance(int value)
 {
     m_cfg.writeEntry("audioOffsetTolerance", value);
 }
 
 bool KisConfig::switchSelectionCtrlAlt(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("switchSelectionCtrlAlt", false);
 }
 
 void KisConfig::setSwitchSelectionCtrlAlt(bool value)
 {
     m_cfg.writeEntry("switchSelectionCtrlAlt", value);
     KisConfigNotifier::instance()->notifyConfigChanged();
 }
 
 bool KisConfig::convertToImageColorspaceOnImport(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("ConvertToImageColorSpaceOnImport", false);
 }
 
 void KisConfig::setConvertToImageColorspaceOnImport(bool value)
 {
     m_cfg.writeEntry("ConvertToImageColorSpaceOnImport", value);
 }
 
 int KisConfig::stabilizerSampleSize(bool defaultValue) const
 {
 #ifdef Q_OS_WIN
     const int defaultSampleSize = 50;
 #else
     const int defaultSampleSize = 15;
 #endif
 
     return defaultValue ?
         defaultSampleSize : m_cfg.readEntry("stabilizerSampleSize", defaultSampleSize);
 }
 
 void KisConfig::setStabilizerSampleSize(int value)
 {
     m_cfg.writeEntry("stabilizerSampleSize", value);
 }
 
 bool KisConfig::stabilizerDelayedPaint(bool defaultValue) const
 {
     const bool defaultEnabled = true;
 
     return defaultValue ?
         defaultEnabled : m_cfg.readEntry("stabilizerDelayedPaint", defaultEnabled);
 }
 
 void KisConfig::setStabilizerDelayedPaint(bool value)
 {
     m_cfg.writeEntry("stabilizerDelayedPaint", value);
 }
 
 bool KisConfig::showBrushHud(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("showBrushHud", false);
 }
 
 void KisConfig::setShowBrushHud(bool value)
 {
     m_cfg.writeEntry("showBrushHud", value);
 }
 
 QString KisConfig::brushHudSetting(bool defaultValue) const
 {
     QString defaultDoc = "<!DOCTYPE hud_properties>\n<hud_properties>\n <version value=\"1\" type=\"value\"/>\n <paintbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"angle\" type=\"value\"/>\n  </properties_list>\n </paintbrush>\n <colorsmudge>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"smudge_mode\" type=\"value\"/>\n   <item_3 value=\"smudge_length\" type=\"value\"/>\n   <item_4 value=\"smudge_color_rate\" type=\"value\"/>\n  </properties_list>\n </colorsmudge>\n <sketchbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </sketchbrush>\n <hairybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </hairybrush>\n <experimentbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"shape_windingfill\" type=\"value\"/>\n  </properties_list>\n </experimentbrush>\n <spraybrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"spray_particlecount\" type=\"value\"/>\n   <item_3 value=\"spray_density\" type=\"value\"/>\n  </properties_list>\n </spraybrush>\n <hatchingbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"hatching_angle\" type=\"value\"/>\n   <item_3 value=\"hatching_thickness\" type=\"value\"/>\n   <item_4 value=\"hatching_separation\" type=\"value\"/>\n  </properties_list>\n </hatchingbrush>\n <gridbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"grid_divisionlevel\" type=\"value\"/>\n  </properties_list>\n </gridbrush>\n <curvebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"curve_historysize\" type=\"value\"/>\n   <item_2 value=\"curve_linewidth\" type=\"value\"/>\n   <item_3 value=\"curve_lineopacity\" type=\"value\"/>\n   <item_4 value=\"curve_connectionline\" type=\"value\"/>\n  </properties_list>\n </curvebrush>\n <dynabrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"dyna_diameter\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"dyna_mass\" type=\"value\"/>\n   <item_3 value=\"dyna_drag\" type=\"value\"/>\n  </properties_list>\n </dynabrush>\n <particlebrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"particle_particles\" type=\"value\"/>\n   <item_2 value=\"particle_opecityweight\" type=\"value\"/>\n   <item_3 value=\"particle_iterations\" type=\"value\"/>\n  </properties_list>\n </particlebrush>\n <duplicate>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"clone_healing\" type=\"value\"/>\n   <item_3 value=\"clone_movesource\" type=\"value\"/>\n  </properties_list>\n </duplicate>\n <deformbrush>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n   <item_2 value=\"deform_amount\" type=\"value\"/>\n   <item_3 value=\"deform_mode\" type=\"value\"/>\n  </properties_list>\n </deformbrush>\n <tangentnormal>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </tangentnormal>\n <filter>\n  <properties_list type=\"array\">\n   <item_0 value=\"size\" type=\"value\"/>\n   <item_1 value=\"opacity\" type=\"value\"/>\n  </properties_list>\n </filter>\n <roundmarker>\n  <properties_list type=\"array\">\n   <item_0 value=\"opacity\" type=\"value\"/>\n   <item_1 value=\"size\" type=\"value\"/>\n  </properties_list>\n </roundmarker>\n</hud_properties>\n";
     return defaultValue ? defaultDoc : m_cfg.readEntry("brushHudSettings", defaultDoc);
 }
 
 void KisConfig::setBrushHudSetting(const QString &value) const
 {
     m_cfg.writeEntry("brushHudSettings", value);
 }
 
 bool KisConfig::calculateAnimationCacheInBackground(bool defaultValue) const
 {
     return defaultValue ? true : m_cfg.readEntry("calculateAnimationCacheInBackground", true);
 }
 
 void KisConfig::setCalculateAnimationCacheInBackground(bool value)
 {
     m_cfg.writeEntry("calculateAnimationCacheInBackground", value);
 }
 
 QColor KisConfig::defaultAssistantsColor(bool defaultValue) const
 {
     static const QColor defaultColor = QColor(176, 176, 176, 255);
     return defaultValue ? defaultColor : m_cfg.readEntry("defaultAssistantsColor", defaultColor);
 }
 
 void KisConfig::setDefaultAssistantsColor(const QColor &color) const
 {
     m_cfg.writeEntry("defaultAssistantsColor", color);
 }
 
 bool KisConfig::autoSmoothBezierCurves(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("autoSmoothBezierCurves", false);
 }
 
 void KisConfig::setAutoSmoothBezierCurves(bool value)
 {
     m_cfg.writeEntry("autoSmoothBezierCurves", value);
 }
 
 bool KisConfig::activateTransformToolAfterPaste(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("activateTransformToolAfterPaste", false);
 }
 
 void KisConfig::setActivateTransformToolAfterPaste(bool value)
 {
     m_cfg.writeEntry("activateTransformToolAfterPaste", value);
 }
 
 KisConfig::RootSurfaceFormat KisConfig::rootSurfaceFormat(bool defaultValue) const
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     return rootSurfaceFormat(&kritarc, defaultValue);
 }
 
 void KisConfig::setRootSurfaceFormat(KisConfig::RootSurfaceFormat value)
 {
     const QString configPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation);
     QSettings kritarc(configPath + QStringLiteral("/kritadisplayrc"), QSettings::IniFormat);
 
     setRootSurfaceFormat(&kritarc, value);
 }
 
 KisConfig::RootSurfaceFormat KisConfig::rootSurfaceFormat(QSettings *displayrc, bool defaultValue)
 {
     QString textValue = "bt709-g22";
 
     if (!defaultValue) {
         textValue = displayrc->value("rootSurfaceFormat", textValue).toString();
     }
 
     return textValue == "bt709-g10" ? BT709_G10 :
            textValue == "bt2020-pq" ? BT2020_PQ :
            BT709_G22;
 }
 
 void KisConfig::setRootSurfaceFormat(QSettings *displayrc, KisConfig::RootSurfaceFormat value)
 {
     const QString textValue =
         value == BT709_G10 ? "bt709-g10" :
         value == BT2020_PQ ? "bt2020-pq" :
         "bt709-g22";
 
     displayrc->setValue("rootSurfaceFormat", textValue);
 }
 
 bool KisConfig::useZip64(bool defaultValue) const
 {
     return defaultValue ? false : m_cfg.readEntry("UseZip64", false);
 }
 
 void KisConfig::setUseZip64(bool value)
 {
     m_cfg.writeEntry("UseZip64", value);
 }
 
 bool KisConfig::convertLayerColorSpaceInProperties(bool defaultValue) const
 {
     return defaultValue ? true : m_cfg.readEntry("convertLayerColorSpaceInProperties", true);
 }
 
 void KisConfig::setConvertLayerColorSpaceInProperties(bool value)
 {
     m_cfg.writeEntry("convertLayerColorSpaceInProperties", value);
 }
 
 #include <QDomDocument>
 #include <QDomElement>
 
 void KisConfig::writeKoColor(const QString& name, const KoColor& color) const
 {
     QDomDocument doc = QDomDocument(name);
     QDomElement el = doc.createElement(name);
     doc.appendChild(el);
     color.toXML(doc, el);
     m_cfg.writeEntry(name, doc.toString());
 }
 
 //ported from kispropertiesconfig.
 KoColor KisConfig::readKoColor(const QString& name, const KoColor& _color) const
 {
     QDomDocument doc;
 
     KoColor color = _color;
 
     if (!m_cfg.readEntry(name).isNull()) {
         doc.setContent(m_cfg.readEntry(name));
         QDomElement e = doc.documentElement().firstChild().toElement();
         color = KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     else {
         QString blackColor = "<!DOCTYPE Color>\n<Color>\n <RGB r=\"0\" space=\"sRGB-elle-V2-srgbtrc.icc\" b=\"0\" g=\"0\"/>\n</Color>\n";
         doc.setContent(blackColor);
         QDomElement e = doc.documentElement().firstChild().toElement();
         color =  KoColor::fromXML(e, Integer16BitsColorDepthID.id());
     }
     return color;
 
 }
diff --git a/libs/ui/kis_config.h b/libs/ui/kis_config.h
index d62fb9173f..7d8636395e 100644
--- a/libs/ui/kis_config.h
+++ b/libs/ui/kis_config.h
@@ -1,659 +1,659 @@
 /*
  *  Copyright (c) 2002 Patrick Julien <freak@codepimps.org>
  *
  *  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; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  */
 #ifndef KIS_CONFIG_H_
 #define KIS_CONFIG_H_
 
 #include <QString>
 #include <QStringList>
 #include <QList>
 #include <QColor>
 #include <QObject>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
 #include <kis_global.h>
 #include <kis_properties_configuration.h>
 #include "kritaui_export.h"
 
 class KoColorProfile;
 class KoColorSpace;
 class KisSnapConfig;
 class QSettings;
 class KisOcioConfiguration;
 
 class KRITAUI_EXPORT KisConfig
 {
 public:
     /**
      * @brief KisConfig create a kisconfig object
      * @param readOnly if true, there will be no call to sync when the object is deleted.
      *  Any KisConfig object created in a thread must be read-only.
      */
     KisConfig(bool readOnly);
 
     ~KisConfig();
 
 public Q_SLOTS:
     /// Log the most interesting settings to the usage log
     void logImportantSettings() const;
 public:
 
     bool disableTouchOnCanvas(bool defaultValue = false) const;
     void setDisableTouchOnCanvas(bool value) const;
 
     bool disableTouchRotation(bool defaultValue = false) const;
     void setDisableTouchRotation(bool value) const;
 
     // XXX Unused?
     bool useProjections(bool defaultValue = false) const;
     void setUseProjections(bool useProj) const;
 
     bool undoEnabled(bool defaultValue = false) const;
     void setUndoEnabled(bool undo) const;
 
     int undoStackLimit(bool defaultValue = false) const;
     void setUndoStackLimit(int limit) const;
 
     bool useCumulativeUndoRedo(bool defaultValue = false) const;
     void setCumulativeUndoRedo(bool value);
 
     double stackT1(bool defaultValue = false) const;
     void setStackT1(int T1);
 
     double stackT2(bool defaultValue = false) const;
     void setStackT2(int T2);
 
     int stackN(bool defaultValue = false) const;
     void setStackN(int N);
 
     qint32 defImageWidth(bool defaultValue = false) const;
     void defImageWidth(qint32 width) const;
 
     qint32 defImageHeight(bool defaultValue = false) const;
     void defImageHeight(qint32 height) const;
 
     qreal defImageResolution(bool defaultValue = false) const;
     void defImageResolution(qreal res) const;
 
     int preferredVectorImportResolutionPPI(bool defaultValue = false) const;
     void setPreferredVectorImportResolutionPPI(int value) const;
 
+    bool rememberLastUsedColorSpace(bool defaultValue = false) const;
+    void setRememberLastUsedColorSpace(bool value) const;
+
     /**
      * @return the id of the default color model used for creating new images.
      */
     QString defColorModel(bool defaultValue = false) const;
     /**
      * set the id of the default color model used for creating new images.
      */
     void defColorModel(const QString & model) const;
 
     /**
      * @return the id of the default color depth used for creating new images.
      */
-    QString defaultColorDepth(bool defaultValue = false) const;
+    QString defColorDepth(bool defaultValue = false) const;
     /**
      * set the id of the default color depth used for creating new images.
      */
-    void setDefaultColorDepth(const QString & depth) const;
+    void defColorDepth(const QString & depth) const;
 
     /**
      * @return the id of the default color profile used for creating new images.
      */
     QString defColorProfile(bool defaultValue = false) const;
     /**
      * set the id of the default color profile used for creating new images.
      */
     void defColorProfile(const QString & depth) const;
 
     CursorStyle newCursorStyle(bool defaultValue = false) const;
     void setNewCursorStyle(CursorStyle style);
 
     QColor getCursorMainColor(bool defaultValue = false) const;
     void setCursorMainColor(const QColor& v) const;
 
     OutlineStyle newOutlineStyle(bool defaultValue = false) const;
     void setNewOutlineStyle(OutlineStyle style);
 
     QRect colorPreviewRect() const;
     void setColorPreviewRect(const QRect &rect);
 
     /// get the profile the user has selected for the given screen
     QString monitorProfile(int screen) const;
     void setMonitorProfile(int screen, const QString & monitorProfile, bool override) const;
 
     QString monitorForScreen(int screen, const QString &defaultMonitor, bool defaultValue = true) const;
     void setMonitorForScreen(int screen, const QString& monitor);
 
     /// Get the actual profile to be used for the given screen, which is
     /// either the screen profile set by the color management system or
     /// the custom monitor profile set by the user, depending on the configuration
     const KoColorProfile *displayProfile(int screen) const;
 
-    QString workingColorSpace(bool defaultValue = false) const;
-    void setWorkingColorSpace(const QString & workingColorSpace) const;
-
     QString importProfile(bool defaultValue = false) const;
     void setImportProfile(const QString & importProfile) const;
 
     QString printerColorSpace(bool defaultValue = false) const;
     void setPrinterColorSpace(const QString & printerColorSpace) const;
 
     QString printerProfile(bool defaultValue = false) const;
     void setPrinterProfile(const QString & printerProfile) const;
 
     bool useBlackPointCompensation(bool defaultValue = false) const;
     void setUseBlackPointCompensation(bool useBlackPointCompensation) const;
 
     bool allowLCMSOptimization(bool defaultValue = false) const;
     void setAllowLCMSOptimization(bool allowLCMSOptimization);
 
     bool forcePaletteColors(bool defaultValue = false) const;
     void setForcePaletteColors(bool forcePaletteColors);
 
     void writeKoColor(const QString& name, const KoColor& color) const;
     KoColor readKoColor(const QString& name, const KoColor& color = KoColor()) const;
 
     bool showRulers(bool defaultValue = false) const;
     void setShowRulers(bool rulers) const;
 
     bool forceShowSaveMessages(bool defaultValue = true) const;
     void setForceShowSaveMessages(bool value) const;
 
     bool forceShowAutosaveMessages(bool defaultValue = true) const;
     void setForceShowAutosaveMessages(bool ShowAutosaveMessages) const;
 
     bool rulersTrackMouse(bool defaultValue = false) const;
     void setRulersTrackMouse(bool value) const;
 
     qint32 pasteBehaviour(bool defaultValue = false) const;
     void setPasteBehaviour(qint32 behaviour) const;
 
     qint32 monitorRenderIntent(bool defaultValue = false) const;
     void setRenderIntent(qint32 monitorRenderIntent) const;
 
     bool useOpenGL(bool defaultValue = false) const;
     void disableOpenGL() const;
 
     int openGLFilteringMode(bool defaultValue = false) const;
     void setOpenGLFilteringMode(int filteringMode);
 
     void setWidgetStyle(QString name);
     QString widgetStyle(bool defaultValue = false);
 
     bool useOpenGLTextureBuffer(bool defaultValue = false) const;
     void setUseOpenGLTextureBuffer(bool useBuffer);
 
     // XXX Unused?
     bool disableVSync(bool defaultValue = false) const;
     void setDisableVSync(bool disableVSync);
 
     bool showAdvancedOpenGLSettings(bool defaultValue = false) const;
 
     bool forceOpenGLFenceWorkaround(bool defaultValue = false) const;
 
     int numMipmapLevels(bool defaultValue = false) const;
     int openGLTextureSize(bool defaultValue = false) const;
     int textureOverlapBorder() const;
 
     quint32 getGridMainStyle(bool defaultValue = false) const;
     void setGridMainStyle(quint32 v) const;
 
     quint32 getGridSubdivisionStyle(bool defaultValue = false) const;
     void setGridSubdivisionStyle(quint32 v) const;
 
     QColor getGridMainColor(bool defaultValue = false) const;
     void setGridMainColor(const QColor & v) const;
 
     QColor getGridSubdivisionColor(bool defaultValue = false) const;
     void setGridSubdivisionColor(const QColor & v) const;
 
     QColor getPixelGridColor(bool defaultValue = false) const;
     void setPixelGridColor(const QColor & v) const;
 
     qreal getPixelGridDrawingThreshold(bool defaultValue = false) const;
     void setPixelGridDrawingThreshold(qreal v) const;
 
     bool pixelGridEnabled(bool defaultValue = false) const;
     void enablePixelGrid(bool v) const;
 
     quint32 guidesLineStyle(bool defaultValue = false) const;
     void setGuidesLineStyle(quint32 v) const;
     QColor guidesColor(bool defaultValue = false) const;
     void setGuidesColor(const QColor & v) const;
 
     void loadSnapConfig(KisSnapConfig *config, bool defaultValue = false) const;
     void saveSnapConfig(const KisSnapConfig &config);
 
     qint32 checkSize(bool defaultValue = false) const;
     void setCheckSize(qint32 checkSize) const;
 
     bool scrollCheckers(bool defaultValue = false) const;
     void setScrollingCheckers(bool scollCheckers) const;
 
     QColor checkersColor1(bool defaultValue = false) const;
     void setCheckersColor1(const QColor & v) const;
 
     QColor checkersColor2(bool defaultValue = false) const;
     void setCheckersColor2(const QColor & v) const;
 
     QColor canvasBorderColor(bool defaultValue = false) const;
     void setCanvasBorderColor(const QColor &color) const;
 
     bool hideScrollbars(bool defaultValue = false) const;
     void setHideScrollbars(bool value) const;
 
     bool antialiasCurves(bool defaultValue = false) const;
     void setAntialiasCurves(bool v) const;
 
     bool antialiasSelectionOutline(bool defaultValue = false) const;
     void setAntialiasSelectionOutline(bool v) const;
 
     bool showRootLayer(bool defaultValue = false) const;
     void setShowRootLayer(bool showRootLayer) const;
 
     bool showGlobalSelection(bool defaultValue = false) const;
     void setShowGlobalSelection(bool showGlobalSelection) const;
 
     bool showOutlineWhilePainting(bool defaultValue = false) const;
     void setShowOutlineWhilePainting(bool showOutlineWhilePainting) const;
 
     bool forceAlwaysFullSizedOutline(bool defaultValue = false) const;
     void setForceAlwaysFullSizedOutline(bool value) const;
 
     enum SessionOnStartup {
         SOS_BlankSession,
         SOS_PreviousSession,
         SOS_ShowSessionManager
     };
     SessionOnStartup sessionOnStartup(bool defaultValue = false) const;
     void setSessionOnStartup(SessionOnStartup value);
 
     bool saveSessionOnQuit(bool defaultValue) const;
     void setSaveSessionOnQuit(bool value);
 
     qreal outlineSizeMinimum(bool defaultValue = false) const;
     void setOutlineSizeMinimum(qreal outlineSizeMinimum) const;
 
     qreal selectionViewSizeMinimum(bool defaultValue = false) const;
     void setSelectionViewSizeMinimum(qreal outlineSizeMinimum) const;
 
     int autoSaveInterval(bool defaultValue = false) const;
     void setAutoSaveInterval(int seconds) const;
 
     bool backupFile(bool defaultValue = false) const;
     void setBackupFile(bool backupFile) const;
 
     bool showFilterGallery(bool defaultValue = false) const;
     void setShowFilterGallery(bool showFilterGallery) const;
 
     bool showFilterGalleryLayerMaskDialog(bool defaultValue = false) const;
     void setShowFilterGalleryLayerMaskDialog(bool showFilterGallery) const;
 
     // OPENGL_SUCCESS, TRY_OPENGL, OPENGL_NOT_TRIED, OPENGL_FAILED
     QString canvasState(bool defaultValue = false) const;
     void setCanvasState(const QString& state) const;
 
     bool toolOptionsPopupDetached(bool defaultValue = false) const;
     void setToolOptionsPopupDetached(bool detached) const;
 
     bool paintopPopupDetached(bool defaultValue = false) const;
     void setPaintopPopupDetached(bool detached) const;
 
     QString pressureTabletCurve(bool defaultValue = false) const;
     void setPressureTabletCurve(const QString& curveString) const;
 
     bool useWin8PointerInput(bool defaultValue = false) const;
     void setUseWin8PointerInput(bool value);
 
     static bool useWin8PointerInputNoApp(QSettings *settings, bool defaultValue = false);
     static void setUseWin8PointerInputNoApp(QSettings *settings, bool value);
 
     bool useRightMiddleTabletButtonWorkaround(bool defaultValue = false) const;
     void setUseRightMiddleTabletButtonWorkaround(bool value);
 
     qreal vastScrolling(bool defaultValue = false) const;
     void setVastScrolling(const qreal factor) const;
 
     int presetChooserViewMode(bool defaultValue = false) const;
     void setPresetChooserViewMode(const int mode) const;
 
     int presetIconSize(bool defaultValue = false) const;
     void setPresetIconSize(const int value) const;
 
 
     bool firstRun(bool defaultValue = false) const;
     void setFirstRun(const bool firstRun) const;
 
     bool clicklessSpacePan(bool defaultValue = false) const;
     void setClicklessSpacePan(const bool toggle) const;
 
     int horizontalSplitLines(bool defaultValue = false) const;
     void setHorizontalSplitLines(const int numberLines) const;
 
     int verticalSplitLines(bool defaultValue = false) const;
     void setVerticalSplitLines(const int numberLines) const;
 
     bool hideDockersFullscreen(bool defaultValue = false) const;
     void setHideDockersFullscreen(const bool value) const;
 
     bool showDockers(bool defaultValue = false) const;
     void setShowDockers(const bool value) const;
 
     bool showStatusBar(bool defaultValue = false) const;
     void setShowStatusBar(const bool value) const;
 
     bool hideMenuFullscreen(bool defaultValue = false) const;
     void setHideMenuFullscreen(const bool value) const;
 
     bool hideScrollbarsFullscreen(bool defaultValue = false) const;
     void setHideScrollbarsFullscreen(const bool value) const;
 
     bool hideStatusbarFullscreen(bool defaultValue = false) const;
     void setHideStatusbarFullscreen(const bool value) const;
 
     bool hideTitlebarFullscreen(bool defaultValue = false) const;
     void setHideTitlebarFullscreen(const bool value) const;
 
     bool hideToolbarFullscreen(bool defaultValue = false) const;
     void setHideToolbarFullscreen(const bool value) const;
 
     bool fullscreenMode(bool defaultValue = false) const;
     void setFullscreenMode(const bool value) const;
 
     QStringList favoriteCompositeOps(bool defaultValue = false) const;
     void setFavoriteCompositeOps(const QStringList& compositeOps) const;
 
     QString exportConfigurationXML(const QString &filterId, bool defaultValue = false) const;
     KisPropertiesConfigurationSP exportConfiguration(const QString &filterId, bool defaultValue = false) const;
     void setExportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const;
 
     QString importConfiguration(const QString &filterId, bool defaultValue = false) const;
     void setImportConfiguration(const QString &filterId, KisPropertiesConfigurationSP properties) const;
 
     bool useOcio(bool defaultValue = false) const;
     void setUseOcio(bool useOCIO) const;
 
     int favoritePresets(bool defaultValue = false) const;
     void setFavoritePresets(const int value);
 
     bool levelOfDetailEnabled(bool defaultValue = false) const;
     void setLevelOfDetailEnabled(bool value);
 
     KisOcioConfiguration ocioConfiguration(bool defaultValue = false) const;
     void setOcioConfiguration(const KisOcioConfiguration &cfg);
 
     enum OcioColorManagementMode {
         INTERNAL = 0,
         OCIO_CONFIG,
         OCIO_ENVIRONMENT
     };
 
     OcioColorManagementMode ocioColorManagementMode(bool defaultValue = false) const;
     void setOcioColorManagementMode(OcioColorManagementMode mode) const;
 
     int ocioLutEdgeSize(bool defaultValue = false) const;
     void setOcioLutEdgeSize(int value);
 
     bool ocioLockColorVisualRepresentation(bool defaultValue = false) const;
     void setOcioLockColorVisualRepresentation(bool value);
 
     bool useSystemMonitorProfile(bool defaultValue = false) const;
     void setUseSystemMonitorProfile(bool _useSystemMonitorProfile) const;
 
     QString defaultPalette(bool defaultValue = false) const;
     void setDefaultPalette(const QString& name) const;
 
     QString toolbarSlider(int sliderNumber, bool defaultValue = false) const;
     void setToolbarSlider(int sliderNumber, const QString &slider);
 
 
     int layerThumbnailSize(bool defaultValue = false) const;
     void setLayerThumbnailSize(int size);
 
 
     bool sliderLabels(bool defaultValue = false) const;
     void setSliderLabels(bool enabled);
 
     QString currentInputProfile(bool defaultValue = false) const;
     void setCurrentInputProfile(const QString& name);
 
     bool presetStripVisible(bool defaultValue = false) const;
     void setPresetStripVisible(bool visible);
 
     bool scratchpadVisible(bool defaultValue = false) const;
     void setScratchpadVisible(bool visible);
 
     bool showSingleChannelAsColor(bool defaultValue = false) const;
     void setShowSingleChannelAsColor(bool asColor);
 
     bool hidePopups(bool defaultValue = false) const;
     void setHidePopups(bool hidepopups);
 
     int numDefaultLayers(bool defaultValue = false) const;
     void setNumDefaultLayers(int num);
 
     quint8 defaultBackgroundOpacity(bool defaultValue = false) const;
     void setDefaultBackgroundOpacity(quint8 value);
 
     QColor defaultBackgroundColor(bool defaultValue = false) const;
     void setDefaultBackgroundColor(const QColor &value);
 
     enum BackgroundStyle {
         RASTER_LAYER = 0,
         CANVAS_COLOR = 1,
         FILL_LAYER = 2
     };
 
     BackgroundStyle defaultBackgroundStyle(bool defaultValue = false) const;
     void setDefaultBackgroundStyle(BackgroundStyle value);
 
     int lineSmoothingType(bool defaultValue = false) const;
     void setLineSmoothingType(int value);
 
     qreal lineSmoothingDistance(bool defaultValue = false) const;
     void setLineSmoothingDistance(qreal value);
 
     qreal lineSmoothingTailAggressiveness(bool defaultValue = false) const;
     void setLineSmoothingTailAggressiveness(qreal value);
 
     bool lineSmoothingSmoothPressure(bool defaultValue = false) const;
     void setLineSmoothingSmoothPressure(bool value);
 
     bool lineSmoothingScalableDistance(bool defaultValue = false) const;
     void setLineSmoothingScalableDistance(bool value);
 
     qreal lineSmoothingDelayDistance(bool defaultValue = false) const;
     void setLineSmoothingDelayDistance(qreal value);
 
     bool lineSmoothingUseDelayDistance(bool defaultValue = false) const;
     void setLineSmoothingUseDelayDistance(bool value);
 
     bool lineSmoothingFinishStabilizedCurve(bool defaultValue = false) const;
     void setLineSmoothingFinishStabilizedCurve(bool value);
 
     bool lineSmoothingStabilizeSensors(bool defaultValue = false) const;
     void setLineSmoothingStabilizeSensors(bool value);
 
     int tabletEventsDelay(bool defaultValue = false) const;
     void setTabletEventsDelay(int value);
 
     bool trackTabletEventLatency(bool defaultValue = false) const;
     void setTrackTabletEventLatency(bool value);
 
     bool testingAcceptCompressedTabletEvents(bool defaultValue = false) const;
     void setTestingAcceptCompressedTabletEvents(bool value);
 
     bool shouldEatDriverShortcuts(bool defaultValue = false) const;
 
     bool testingCompressBrushEvents(bool defaultValue = false) const;
     void setTestingCompressBrushEvents(bool value);
 
     const KoColorSpace* customColorSelectorColorSpace(bool defaultValue = false) const;
     void setCustomColorSelectorColorSpace(const KoColorSpace *cs);
 
     bool useDirtyPresets(bool defaultValue = false) const;
     void setUseDirtyPresets(bool value);
 
     bool useEraserBrushSize(bool defaultValue = false) const;
     void setUseEraserBrushSize(bool value);
 
     bool useEraserBrushOpacity(bool defaultValue = false) const;
     void setUseEraserBrushOpacity(bool value);
 
     QString getMDIBackgroundColor(bool defaultValue = false) const;
     void setMDIBackgroundColor(const QString & v) const;
 
     QString getMDIBackgroundImage(bool defaultValue = false) const;
     void setMDIBackgroundImage(const QString & fileName) const;
 
     int workaroundX11SmoothPressureSteps(bool defaultValue = false) const;
 
     bool showCanvasMessages(bool defaultValue = false) const;
     void setShowCanvasMessages(bool show);
 
     bool compressKra(bool defaultValue = false) const;
     void setCompressKra(bool compress);
 
     bool trimKra(bool defaultValue = false) const;
     void setTrimKra(bool trim);
 
     bool toolOptionsInDocker(bool defaultValue = false) const;
     void setToolOptionsInDocker(bool inDocker);
 
     bool kineticScrollingEnabled(bool defaultValue = false) const;
     void setKineticScrollingEnabled(bool enabled);
 
     int kineticScrollingGesture(bool defaultValue = false) const;
     void setKineticScrollingGesture(int kineticScroll);
 
     int kineticScrollingSensitivity(bool defaultValue = false) const;
     void setKineticScrollingSensitivity(int sensitivity);
 
     bool kineticScrollingHiddenScrollbars(bool defaultValue = false) const;
     void setKineticScrollingHideScrollbars(bool scrollbar);
 
     void setEnableOpenGLFramerateLogging(bool value) const;
     bool enableOpenGLFramerateLogging(bool defaultValue = false) const;
 
     void setEnableBrushSpeedLogging(bool value) const;
     bool enableBrushSpeedLogging(bool defaultValue = false) const;
 
     void setEnableAmdVectorizationWorkaround(bool value);
     bool enableAmdVectorizationWorkaround(bool defaultValue = false) const;
 
     void setDisableAVXOptimizations(bool value);
     bool disableAVXOptimizations(bool defaultValue = false) const;
 
     bool animationDropFrames(bool defaultValue = false) const;
     void setAnimationDropFrames(bool value);
 
     bool autoPinLayersToTimeline(bool defaultValue = false) const;
     void setAutoPinLayersToTimeline(bool value);
 
     int scrubbingUpdatesDelay(bool defaultValue = false) const;
     void setScrubbingUpdatesDelay(int value);
 
     int scrubbingAudioUpdatesDelay(bool defaultValue = false) const;
     void setScrubbingAudioUpdatesDelay(int value);
 
     int audioOffsetTolerance(bool defaultValue = false) const;
     void setAudioOffsetTolerance(int value);
 
     bool switchSelectionCtrlAlt(bool defaultValue = false) const;
     void setSwitchSelectionCtrlAlt(bool value);
 
     bool convertToImageColorspaceOnImport(bool defaultValue = false) const;
     void setConvertToImageColorspaceOnImport(bool value);
 
     int stabilizerSampleSize(bool defaultValue = false) const;
     void setStabilizerSampleSize(int value);
 
     bool stabilizerDelayedPaint(bool defaultValue = false) const;
     void setStabilizerDelayedPaint(bool value);
 
     bool showBrushHud(bool defaultValue = false) const;
     void setShowBrushHud(bool value);
 
     QString brushHudSetting(bool defaultValue = false) const;
     void setBrushHudSetting(const QString &value) const;
 
     bool calculateAnimationCacheInBackground(bool defaultValue = false) const;
     void setCalculateAnimationCacheInBackground(bool value);
 
     QColor defaultAssistantsColor(bool defaultValue = false) const;
     void setDefaultAssistantsColor(const QColor &color) const;
 
     bool autoSmoothBezierCurves(bool defaultValue = false) const;
     void setAutoSmoothBezierCurves(bool value);
     
     bool activateTransformToolAfterPaste(bool defaultValue = false) const;
     void setActivateTransformToolAfterPaste(bool value);
     
     enum RootSurfaceFormat {
         BT709_G22 = 0,
         BT709_G10,
         BT2020_PQ
     };
     RootSurfaceFormat rootSurfaceFormat(bool defaultValue = false) const;
     void setRootSurfaceFormat(RootSurfaceFormat value);
 
     static RootSurfaceFormat rootSurfaceFormat(QSettings *displayrc, bool defaultValue = false);
     static void setRootSurfaceFormat(QSettings *displayrc, RootSurfaceFormat value);
 
     bool useZip64(bool defaultValue = false) const;
     void setUseZip64(bool value);
 
     bool convertLayerColorSpaceInProperties(bool defaultValue = false) const;
     void setConvertLayerColorSpaceInProperties(bool value);
 
     template<class T>
     void writeEntry(const QString& name, const T& value) {
         m_cfg.writeEntry(name, value);
     }
 
     template<class T>
     void writeList(const QString& name, const QList<T>& value) {
         m_cfg.writeEntry(name, value);
     }
 
     template<class T>
     T readEntry(const QString& name, const T& defaultValue=T()) {
         return m_cfg.readEntry(name, defaultValue);
     }
 
     template<class T>
     QList<T> readList(const QString& name, const QList<T>& defaultValue=QList<T>()) {
         return m_cfg.readEntry(name, defaultValue);
     }
 
 
     /// get the profile the color management system has stored for the given screen
     static const KoColorProfile* getScreenProfile(int screen);
 
 private:
     KisConfig(const KisConfig&);
     KisConfig& operator=(const KisConfig&) const;
 
 
 private:
     mutable KConfigGroup m_cfg;
     bool m_readOnly;
 };
 
 #endif // KIS_CONFIG_H_